sibujs 4.12.0 → 4.13.1

package/dist/build.js

@@ -1,18 +1,18 @@
 import {
   index_exports
-} from "./chunk-ZTYCCBU3.js";
-import "./chunk-T5O2CUHV.js";
+} from "./chunk-VFPLWUT7.js";
+import "./chunk-5XUGJM3J.js";
 import "./chunk-2F4PSJ5Z.js";
 import "./chunk-AM6DZLBM.js";
-import "./chunk-HXT2RNH5.js";
-import "./chunk-WFRQ6D7H.js";
+import "./chunk-ADZHPN2B.js";
+import "./chunk-22OPSWMF.js";
 import "./chunk-62BDYGAG.js";
-import "./chunk-WH4U2VUE.js";
-import "./chunk-XX4BRMWF.js";
+import "./chunk-CPQKWCJ2.js";
+import "./chunk-K4LNUT5L.js";
 import "./chunk-F2UWOZ6J.js";
-import "./chunk-RK7EPQPG.js";
+import "./chunk-YFTBCCVH.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-EMB5PG7V.js";
+import "./chunk-QC3NP47A.js";
 import {
   isEventHandlerAttr,
   isHtmlContentAttribute,
@@ -20,78 +20,352 @@ import {
 } from "./chunk-EXXSN3BW.js";
 import "./chunk-7XHATCIH.js";
 import "./chunk-5HZXGZ6T.js";
-import "./chunk-IHA62NGJ.js";
-import "./chunk-B2Y5BJSP.js";
+import "./chunk-QKFVMIAV.js";
+import "./chunk-4UTGDVSA.js";
 import "./chunk-NYNYSPK7.js";
 
-// src/build/sourceEdit.ts
-function isLineBreak(c) {
-  return c === 10 || c === 13 || c === 8232 || c === 8233;
+// src/build/analyzer.ts
+var moduleSizes = {
+  // Core modules
+  "core/html": 1800,
+  "core/mount": 120,
+  "core/each": 450,
+  "core/slots": 200,
+  "core/fragment": 180,
+  "core/catch": 280,
+  "core/portal": 350,
+  "core/directives": 520,
+  "core/dynamic": 380,
+  "core/head": 300,
+  "core/ssr": 1200,
+  "core/customElement": 650,
+  "core/scopedStyle": 480,
+  "core/domRecycler": 420,
+  "core/bundleOptimize": 200,
+  "core/compiled": 350,
+  "core/normalize": 280,
+  "core/reactiveAttr": 320,
+  "core/componentProps": 400,
+  "core/contracts": 350,
+  "core/worker": 550,
+  "core/wasm": 480,
+  "core/concurrent": 600,
+  "core/microfrontend": 700,
+  "core/chunkLoader": 450,
+  "core/versioning": 300,
+  "core/ecosystem": 250,
+  // Signals
+  "core/signal": 280,
+  "core/effect": 350,
+  "core/derived": 250,
+  "core/watch": 300,
+  "core/store": 380,
+  "core/ref": 150,
+  "core/array": 420,
+  "core/deepSignal": 500,
+  "core/lifecycle": 300,
+  "core/context": 350,
+  "core/persist": 400,
+  "core/hoc": 280,
+  "core/transition": 600,
+  "core/form": 750,
+  "core/globalStore": 450,
+  "core/machine": 550,
+  "core/optimistic": 380,
+  "core/timeTravel": 500,
+  "core/scheduler": 350,
+  "core/plugin": 300,
+  "core/virtualList": 800,
+  "core/intersection": 350,
+  "core/inputMask": 450,
+  "core/a11y": 500,
+  "core/debug": 400,
+  "core/serviceWorker": 350,
+  "core/composable": 280,
+  // Reactivity
+  "reactivity/signal": 100,
+  "reactivity/track": 250,
+  "reactivity/batch": 200,
+  "reactivity/bindAttribute": 300,
+  "reactivity/bindChildNode": 250,
+  "reactivity/bindTextNode": 200,
+  // Components
+  "components/ErrorBoundary": 350,
+  "components/Loading": 250,
+  // Plugins
+  "plugins/i18n": 600,
+  "plugins/router": 900,
+  "plugins/routerSSR": 500,
+  // Build utilities
+  "build/vite": 800,
+  "build/webpack": 750,
+  "build/cdn": 400,
+  "build/declarations": 500,
+  "build/analyzer": 600,
+  // Testing
+  "testing/index": 700,
+  "testing/e2e": 500
+};
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
 }
-function lineBreaksIn(code, start, end) {
-  let out = "";
-  for (let i = start; i < end; i++) {
-    if (isLineBreak(code.charCodeAt(i))) out += code[i];
+function analyzeBundle(modules) {
+  const sizes = {};
+  let totalSize = 0;
+  for (const [name, source] of Object.entries(modules)) {
+    let byteLength;
+    if (typeof TextEncoder !== "undefined") {
+      byteLength = new TextEncoder().encode(source).length;
+    } else {
+      byteLength = source.length;
+    }
+    sizes[name] = byteLength;
+    totalSize += byteLength;
   }
-  return out;
+  const sorted = Object.entries(sizes).map(([name, size]) => ({
+    name,
+    size,
+    percentage: totalSize > 0 ? size / totalSize * 100 : 0
+  })).sort((a, b) => b.size - a.size);
+  return {
+    totalSize,
+    moduleSizes: sizes,
+    sorted,
+    report() {
+      const lines = [
+        "=== SibuJS Bundle Analysis ===",
+        "",
+        `Total size: ${formatBytes(totalSize)}`,
+        `Modules: ${sorted.length}`,
+        "",
+        "Module breakdown:",
+        "-".repeat(60)
+      ];
+      for (const entry of sorted) {
+        const sizeStr = formatBytes(entry.size).padStart(10);
+        const pctStr = `${entry.percentage.toFixed(1)}%`.padStart(6);
+        const bar = generateBar(entry.percentage, 20);
+        lines.push(`  ${sizeStr}  ${pctStr}  ${bar}  ${entry.name}`);
+      }
+      lines.push("-".repeat(60));
+      return lines.join("\n");
+    }
+  };
 }
-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 generateBar(percentage, width) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  return `[${"#".repeat(filled)}${".".repeat(empty)}]`;
 }
-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;
+function estimateImportSize(imports) {
+  const breakdown = {};
+  let estimated = 0;
+  const implicitDeps = ["reactivity/signal", "reactivity/track"];
+  const allImports = [.../* @__PURE__ */ new Set([...implicitDeps, ...imports])];
+  for (const importPath of allImports) {
+    const size = moduleSizes[importPath];
+    if (size !== void 0) {
+      breakdown[importPath] = size;
+      estimated += size;
+    } else {
+      const avgSize = 350;
+      breakdown[importPath] = avgSize;
+      estimated += avgSize;
+    }
   }
-  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;
+  const sortedEntries = Object.entries(breakdown).sort(([, a], [, b]) => b - a);
+  const lines = [`Estimated bundle size: ${formatBytes(estimated)} (minified + gzipped)`, ""];
+  for (const [modulePath, size] of sortedEntries) {
+    const known = moduleSizes[modulePath] !== void 0;
+    lines.push(`  ${modulePath}: ${formatBytes(size)}${known ? "" : " (estimated)"}`);
   }
-  return out + code.slice(pos) + append;
+  if (imports.length > 0) {
+    lines.push("");
+    lines.push("Note: Actual sizes may vary based on tree-shaking and build configuration.");
+    lines.push("Implicit dependencies (reactivity/signal, reactivity/track) are included.");
+  }
+  return {
+    estimated,
+    breakdown,
+    formatted: lines.join("\n")
+  };
 }
-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;
+
+// src/build/cdn.ts
+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 };
 }
-function isWordStart(c) {
-  return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 95 || c === 36 || c > 127 || c >= 48 && c <= 57;
+function umdWrapper(name, factory) {
+  const factoryStr = factory.toString();
+  return `(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD (RequireJS)
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    // CommonJS (Node.js)
+    module.exports = factory();
+  } else {
+    // Browser globals
+    root.${name} = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, ${factoryStr}));`;
 }
-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) => {
+var cdnUrls = {
+  /**
+   * Generate an unpkg CDN URL.
+   * @param version - Package version (defaults to 'latest')
+   */
+  unpkg: (version) => `https://unpkg.com/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
+  /**
+   * Generate a jsDelivr CDN URL.
+   * @param version - Package version (defaults to 'latest')
+   */
+  jsdelivr: (version) => `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
+  /**
+   * Generate a Skypack CDN URL (ESM-native).
+   * @param version - Package version (defaults to 'latest')
+   */
+  skypack: (version) => `https://cdn.skypack.dev/${PACKAGE_NAME}@${version || "latest"}`,
+  /**
+   * Generate a complete HTML script tag for including SibuJS from a CDN.
+   *
+   * @param provider - CDN provider to use (defaults to 'jsdelivr')
+   * @param version - Package version (defaults to 'latest')
+   * @returns An HTML script tag string
+   *
+   * @example
+   * ```ts
+   * cdnUrls.scriptTag('jsdelivr', '1.0.0')
+   * // => '<script src="https://cdn.jsdelivr.net/npm/sibujs@1.0.0/dist/cdn.global.js"></script>'
+   * ```
+   */
+  scriptTag: (provider = "jsdelivr", version) => {
+    const url = cdnUrls[provider](version);
+    if (provider === "skypack") {
+      return `<script type="module">
+import * as Sibu from '${url}';
+window.Sibu = Sibu;
+</script>`;
+    }
+    return `<script src="${url}"></script>`;
+  }
+};
+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`
+  };
+  for (const entry of SUBPATH_ENTRIES) {
+    imports[`${PACKAGE_NAME}/${entry}`] = `${base}/dist/${entry}.js`;
+  }
+  return {
+    imports,
+    /**
+     * Serialize the import map to a JSON string.
+     */
+    toJSON() {
+      return JSON.stringify({ imports }, null, 2);
+    },
+    /**
+     * Generate a complete `<script type="importmap">` tag.
+     */
+    toScriptTag() {
+      return `<script type="importmap">
+${JSON.stringify({ imports }, null, 2)}
+</script>`;
+    }
+  };
+}
+
+// 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;
@@ -725,285 +999,77 @@ function importsSibu(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"
-]);
+// src/build/templateCompiler.ts
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
   "br",
+  "col",
+  "embed",
   "hr",
   "img",
   "input",
-  "meta",
   "link",
-  "area",
-  "base",
-  "col",
-  "embed",
+  "meta",
   "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 };
+var SVG_TAGS = /* @__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 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++) {
+    template += `\0${i}\0${strings[i + 1]}`;
   }
-  if (tok.type === "number" && /^(0|[1-9]\d*)(\.\d+)?$/.test(tok.value)) {
-    return { kind: "number", value: String(Number(tok.value)) };
+  let pos = 0;
+  const len = template.length;
+  function skipWs() {
+    while (pos < len && (template[pos] === " " || template[pos] === "	" || template[pos] === "\n" || template[pos] === "\r"))
+      pos++;
   }
-  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/templateCompiler.ts
-var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
-var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-var SVG_TAGS = /* @__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 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++) {
-    template += `\0${i}\0${strings[i + 1]}`;
-  }
-  let pos = 0;
-  const len = template.length;
-  function skipWs() {
-    while (pos < len && (template[pos] === " " || template[pos] === "	" || template[pos] === "\n" || template[pos] === "\r"))
-      pos++;
-  }
-  function tryExprIdx() {
-    if (template.charCodeAt(pos) !== 0) return -1;
-    const start = pos;
-    pos++;
-    let idx = 0;
-    while (pos < len && template.charCodeAt(pos) !== 0) {
-      idx = idx * 10 + (template.charCodeAt(pos) - 48);
-      pos++;
-    }
-    if (pos < len) pos++;
-    if (idx < 0 || idx >= exprCount) {
-      pos = start;
-      return -1;
-    }
-    return idx;
+  function tryExprIdx() {
+    if (template.charCodeAt(pos) !== 0) return -1;
+    const start = pos;
+    pos++;
+    let idx = 0;
+    while (pos < len && template.charCodeAt(pos) !== 0) {
+      idx = idx * 10 + (template.charCodeAt(pos) - 48);
+      pos++;
+    }
+    if (pos < len) pos++;
+    if (idx < 0 || idx >= exprCount) {
+      pos = start;
+      return -1;
+    }
+    return idx;
   }
   function readTagName() {
     const start = pos;
@@ -1143,7 +1209,7 @@ function parseTemplate(strings) {
         const tag = readTagName();
         const attrs = parseAttrs();
         skipWs();
-        const isVoid = VOID_ELEMENTS2.has(tag);
+        const isVoid = VOID_ELEMENTS.has(tag);
         const isSelfClosing = template[pos] === "/";
         if (isSelfClosing) pos++;
         if (pos < len) pos++;
@@ -1433,847 +1499,693 @@ ${trailer}
   return plan;
 }
 
-// src/build/vite.ts
-var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
-var DEFAULT_EXCLUDE = ["node_modules/**", "dist/**", "**/*.test.*", "**/*.spec.*"];
-function matchesPattern(filePath, patterns) {
-  const normalized = filePath.replace(/\\/g, "/");
-  return patterns.some((pattern) => {
-    const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-    return new RegExp(regexStr).test(normalized);
-  });
-}
-function devPrologueEdit(code) {
-  let at = 0;
-  if (code.startsWith("#!")) {
-    const nl = code.indexOf("\n");
-    if (nl === -1) return null;
-    at = nl + 1;
-  }
+// src/build/compileTemplates.ts
+function compileHtmlTemplates(code) {
+  const plan = planHtmlTemplates(code);
+  const edits = plan.compiledCount > 0 ? normalizeEdits(plan.edits) : null;
   return {
-    start: at,
-    end: at,
-    text: '/* SibuJS Dev Mode */ if (typeof globalThis !== "undefined") { globalThis.__SIBU_DEV__ = true; } '
+    code: edits ? applyEdits(code, edits, plan.append) : null,
+    usedTags: plan.usedTags,
+    usesSvg: plan.usesSvg,
+    compiledCount: edits ? plan.compiledCount : 0,
+    skippedCount: plan.skippedCount
   };
 }
-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 {
-    hmr = true,
-    pureAnnotations = true,
-    include = DEFAULT_INCLUDE,
-    exclude = DEFAULT_EXCLUDE,
-    devMode,
-    staticOptimize = false,
-    compileTemplates
-  } = options;
-  let isDevMode = resolveDevMode(devMode, void 0);
+
+// src/build/declarations.ts
+var RECOMMENDED_OPTIONS = {
+  target: "ES2020",
+  module: "ESNext",
+  moduleResolution: "bundler",
+  strict: true,
+  esModuleInterop: true,
+  skipLibCheck: true,
+  declaration: true,
+  declarationMap: true,
+  sourceMap: true,
+  jsx: "preserve",
+  lib: ["ES2020", "DOM", "DOM.Iterable"],
+  isolatedModules: true,
+  resolveJsonModule: true,
+  allowSyntheticDefaultImports: true,
+  forceConsistentCasingInFileNames: true,
+  noUncheckedIndexedAccess: true,
+  noEmit: false
+};
+var REQUIRED_OPTIONS = {
+  strict: {
+    value: true,
+    reason: "SibuJS relies on strict type checking for safe reactive state handling."
+  },
+  esModuleInterop: {
+    value: true,
+    reason: "Required for correct ESM interop with SibuJS module exports."
+  },
+  moduleResolution: {
+    value: ["node", "bundler", "node16", "nodenext"],
+    reason: "SibuJS requires a module resolution strategy that supports package.json exports."
+  }
+};
+var SUGGESTED_OPTIONS = {
+  declarationMap: {
+    value: true,
+    reason: 'Enables "Go to Definition" to navigate to SibuJS source files in your IDE.'
+  },
+  sourceMap: {
+    value: true,
+    reason: "Enables source map debugging for SibuJS components."
+  },
+  noUncheckedIndexedAccess: {
+    value: true,
+    reason: "Improves type safety when accessing reactive state objects."
+  },
+  isolatedModules: {
+    value: true,
+    reason: "Required for compatibility with esbuild/swc transpilers used by Vite."
+  }
+};
+function generateTsConfig(options) {
+  const { target = "ES2020", outDir = "dist", declarationMap = true, paths } = options || {};
+  const compilerOptions = {
+    ...RECOMMENDED_OPTIONS,
+    target,
+    outDir,
+    declarationMap
+  };
+  if (paths && Object.keys(paths).length > 0) {
+    compilerOptions.baseUrl = ".";
+    compilerOptions.paths = {
+      // Default sibujs alias
+      sibujs: ["node_modules/sibujs/dist/index.d.ts"],
+      "sibujs/*": ["node_modules/sibujs/dist/*"],
+      // User-provided paths
+      ...paths
+    };
+  }
   return {
-    name: "sibu-vite-plugin",
-    enforce: "pre",
-    config(_userConfig, env) {
-      isDevMode = resolveDevMode(devMode, env);
-      return {
-        // Optimize dependency pre-bundling for sibujs
-        optimizeDeps: {
-          include: ["sibujs"]
-        },
-        // Ensure sibujs is treated correctly for SSR
-        ssr: {
-          noExternal: ["sibujs"]
-        },
-        // Define global constants for dead code elimination
-        define: {
-          __SIBU_DEV__: JSON.stringify(isDevMode),
-          __SIBU_HMR__: JSON.stringify(hmr)
-        },
-        // Enable source maps in dev
-        build: {
-          sourcemap: isDevMode
-        }
-      };
-    },
-    configResolved(config) {
-      isDevMode = resolveDevMode(devMode, config);
-    },
-    transform(code, id) {
-      if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {
-        return null;
-      }
-      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 (pureAnnotations) {
-        edits.push(...pureAnnotationEdits(code));
-      }
-      const shouldCompile = compileTemplates ?? !isDevMode;
-      if (shouldCompile) {
-        const plan = planHtmlTemplates(code);
-        if (plan.compiledCount > 0) {
-          edits.push(...plan.edits);
-          append += plan.append;
-        }
-      }
-      if (staticOptimize) {
-        const optimized = staticOptimizationEdits(code);
-        if (optimized) {
-          edits.push(...optimized.edits);
-          append += optimized.append;
-        }
-      }
-      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: editsSourceMap(code, sorted, append, id)
-      };
-    },
-    handleHotUpdate(ctx) {
-      if (!hmr) return;
-      const { file } = ctx;
-      if (matchesPattern(file, include) && !matchesPattern(file, exclude)) {
-        if (isDevMode) {
-          console.log(`[sibu-vite-plugin] HMR update: ${file}`);
-        }
-        return;
-      }
-    }
+    compilerOptions,
+    include: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
   };
 }
-function createViteConfig(options = {}) {
-  const { entry = "src/main.ts", outDir = "dist", ssr = false, overrides = {} } = options;
-  const baseConfig = {
-    // Use the SibuJS Vite plugin
-    plugins: [sibuVitePlugin()],
-    // Build configuration
-    build: {
-      outDir,
-      target: "es2020",
-      minify: "esbuild",
-      sourcemap: true,
-      // Library mode configuration when building a library
-      lib: ssr ? void 0 : {
-        entry,
-        formats: ["es", "cjs"]
-      },
-      // Rollup-specific options
-      rollupOptions: {
-        input: ssr ? entry : void 0,
-        output: {
-          // Ensure consistent chunk naming
-          chunkFileNames: "chunks/[name]-[hash].js",
-          // Preserve pure annotations
-          generatedCode: {
-            constBindings: true
-          }
-        },
-        // Tree-shaking configuration
-        treeshake: {
-          moduleSideEffects: false,
-          propertyReadSideEffects: false,
-          annotations: true
-        }
+function validateTsConfig(config) {
+  const warnings = [];
+  const suggestions = [];
+  const compilerOptions = config.compilerOptions || {};
+  for (const [option, requirement] of Object.entries(REQUIRED_OPTIONS)) {
+    const currentValue = compilerOptions[option];
+    if (Array.isArray(requirement.value)) {
+      if (currentValue === void 0) {
+        warnings.push(
+          `Missing required option "${option}". ${requirement.reason} Recommended value: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
+        );
+      } else if (!requirement.value.includes(currentValue)) {
+        warnings.push(
+          `Option "${option}" is set to "${currentValue}" which may not be compatible with SibuJS. ${requirement.reason} Recommended: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
+        );
       }
-    },
-    // Resolve configuration
-    resolve: {
-      // Prefer ESM versions of packages
-      mainFields: ["module", "jsnext:main", "jsnext", "main"],
-      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"]
-    },
-    // SSR configuration
-    ...ssr ? {
-      ssr: {
-        noExternal: ["sibujs"],
-        target: "node"
-      },
-      build: {
-        outDir,
-        target: "node18",
-        ssr: true,
-        rollupOptions: {
-          input: entry,
-          output: {
-            format: "esm"
-          }
-        }
+    } else {
+      if (currentValue === void 0) {
+        warnings.push(
+          `Missing required option "${option}". ${requirement.reason} Recommended value: ${JSON.stringify(requirement.value)}.`
+        );
+      } else if (currentValue !== requirement.value) {
+        warnings.push(
+          `Option "${option}" is set to ${JSON.stringify(currentValue)} but SibuJS recommends ${JSON.stringify(requirement.value)}. ${requirement.reason}`
+        );
       }
-    } : {},
-    // Optimize dependency handling
-    optimizeDeps: {
-      include: ["sibujs"],
-      // Force pre-bundling of sibujs for faster dev startup
-      force: false
-    },
-    // Environment variable handling
-    define: {
-      __SIBU_SSR__: JSON.stringify(ssr)
     }
-  };
-  return deepMerge(baseConfig, overrides);
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
-      result[key] = deepMerge(target[key], source[key]);
-    } else {
-      result[key] = source[key];
+  }
+  for (const [option, suggestion] of Object.entries(SUGGESTED_OPTIONS)) {
+    const currentValue = compilerOptions[option];
+    if (currentValue === void 0 || currentValue !== suggestion.value) {
+      suggestions.push(`Consider setting "${option}" to ${JSON.stringify(suggestion.value)}. ${suggestion.reason}`);
     }
   }
-  return result;
+  const target = typeof compilerOptions.target === "string" ? compilerOptions.target.toUpperCase() : void 0;
+  if (target) {
+    const es2020Plus = ["ES2020", "ES2021", "ES2022", "ES2023", "ES2024", "ESNEXT"];
+    if (!es2020Plus.includes(target)) {
+      warnings.push(
+        `Target "${target}" may not support all features used by SibuJS. Recommended: "ES2020" or newer. SibuJS uses optional chaining, nullish coalescing, and other ES2020+ features.`
+      );
+    }
+  }
+  const module = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
+  if (module && !["esnext", "es2020", "es2022", "node16", "nodenext"].includes(module)) {
+    suggestions.push(
+      `Module "${compilerOptions.module}" may not provide optimal results with SibuJS. Consider using "ESNext" for best tree-shaking and bundle optimization.`
+    );
+  }
+  const lib = compilerOptions.lib;
+  if (Array.isArray(lib)) {
+    const hasDom = lib.some((l) => l.toUpperCase() === "DOM" || l.toUpperCase() === "DOM.ITERABLE");
+    if (!hasDom) {
+      suggestions.push(
+        'The "lib" array does not include "DOM". SibuJS requires DOM types for component rendering. Add "DOM" and "DOM.Iterable" to your lib array.'
+      );
+    }
+  }
+  if (Array.isArray(config.include)) {
+    const includesTs = config.include.some(
+      (pattern) => pattern.includes(".ts") || pattern.includes("*")
+    );
+    if (!includesTs) {
+      suggestions.push(
+        'Your "include" patterns may not capture TypeScript files. Ensure patterns like "src/**/*.ts" are included.'
+      );
+    }
+  }
+  return {
+    valid: warnings.length === 0,
+    warnings,
+    suggestions
+  };
 }
 
-// src/build/webpack.ts
-function addPureAnnotations(source) {
-  return injectPureAnnotations(source);
-}
-function sibuWebpackPlugin(options = {}) {
-  const { devMode } = options;
-  return {
-    name: "SibuWebpackPlugin",
-    apply(compiler) {
-      if (options.pureAnnotations === true) {
-        console.warn(
-          '[SibuWebpackPlugin] `pureAnnotations` is not applied by the plugin: webpack needs a loader file. Create sibu-pure-loader.cjs containing `module.exports = require("sibujs/build").createPureAnnotationsLoader();` and add a module rule `{ test: /\\.[cm]?[jt]sx?$/, exclude: /node_modules/, use: "./sibu-pure-loader.cjs" }`.'
-        );
-      }
-      compiler.hooks?.compilation?.tap("SibuWebpackPlugin", (compilation) => {
-        const comp = compilation;
-        if (comp.hooks?.optimizeModules) {
-          comp.hooks.optimizeModules.tap("SibuWebpackPlugin", () => {
-          });
-        }
-      });
-      compiler.hooks?.afterResolvers?.tap("SibuWebpackPlugin", () => {
-        if (!compiler.options.resolve) {
-          compiler.options.resolve = {};
-        }
-        if (!compiler.options.resolve.mainFields) {
-          compiler.options.resolve.mainFields = ["module", "main"];
-        }
-        if (!compiler.options.resolve.mainFields.includes("module")) {
-          compiler.options.resolve.mainFields.unshift("module");
+// src/build/ide.ts
+function getComponentMetadata() {
+  return [
+    // ── Reactive Primitives ──────────────────────────────────────────
+    {
+      name: "signal",
+      description: "Creates a reactive signal that holds a value. Returns a [getter, setter] tuple. The getter registers reactive dependencies when called.",
+      props: [
+        {
+          name: "initial",
+          type: "T",
+          required: true,
+          description: "The initial value of the state"
         }
-      });
-      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)`);
-          }
+      ]
+    },
+    {
+      name: "effect",
+      description: "Runs a side effect function immediately and re-runs it whenever any reactive dependency changes. Returns a cleanup function.",
+      props: [
+        {
+          name: "effectFn",
+          type: "() => void",
+          required: true,
+          description: "The effect function to run. It is tracked for reactive dependencies."
         }
-      });
-      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 = [];
+      ]
+    },
+    {
+      name: "derived",
+      description: "Creates a derived reactive signal whose value updates automatically when dependencies change. Returns a getter function.",
+      props: [
+        {
+          name: "getter",
+          type: "() => T",
+          required: true,
+          description: "Function returning the computed value based on reactive signals"
         }
-        const defines = {
-          __SIBU_DEV__: JSON.stringify(isDevMode)
-        };
-        compiler.__sibuDefines = defines;
-        const DefinePlugin = compiler.webpack?.DefinePlugin;
-        if (DefinePlugin) {
-          new DefinePlugin(defines).apply(compiler);
+      ]
+    },
+    {
+      name: "ref",
+      description: "Creates a mutable reference object that persists across renders. Updating a ref does NOT trigger re-renders.",
+      props: [
+        {
+          name: "initial",
+          type: "T",
+          required: false,
+          default: "undefined",
+          description: "Optional initial value for the ref"
         }
-      });
-    }
-  };
-}
-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);
-  };
-}
-function createWebpackConfig(options = {}) {
-  const { entry = "./src/index.ts", outputPath = "dist", mode = "production" } = options;
-  const isDev = mode === "development";
-  return {
-    mode,
-    entry,
-    output: {
-      path: outputPath,
-      filename: isDev ? "[name].js" : "[name].[contenthash:8].js",
-      chunkFilename: isDev ? "[name].chunk.js" : "[name].[contenthash:8].chunk.js",
-      clean: true,
-      // Use ESM output
-      module: true,
-      library: {
-        type: "module"
-      }
+      ]
     },
-    // Enable experiments for ESM output
-    experiments: {
-      outputModule: true
+    {
+      name: "watch",
+      description: "Watches a reactive getter and calls a callback with (newValue, oldValue) when the watched value changes. Returns a teardown function.",
+      props: [
+        {
+          name: "getter",
+          type: "() => T",
+          required: true,
+          description: "Function that returns the value to watch"
+        },
+        {
+          name: "callback",
+          type: "(value: T, prev: T | undefined) => void",
+          required: true,
+          description: "Function called when the watched value changes"
+        }
+      ]
     },
-    resolve: {
-      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"],
-      mainFields: ["module", "main"],
-      alias: {}
+    {
+      name: "store",
+      description: "Creates a global store with reactive properties and subscription support. Returns a [store, actions] tuple.",
+      props: [
+        {
+          name: "initialState",
+          type: "T extends object",
+          required: true,
+          description: "Initial state object for the store"
+        }
+      ]
     },
-    module: {
-      rules: [
-        // TypeScript/JavaScript handling
+    // ── Lifecycle ────────────────────────────────────────────────────
+    {
+      name: "onMount",
+      description: "Runs a callback once the component element has been inserted into the DOM. Uses queueMicrotask for deferred execution.",
+      props: [
         {
-          test: /\.[jt]sx?$/,
-          exclude: /node_modules/,
-          use: [
-            {
-              // Users should configure their preferred TS loader
-              // (ts-loader, babel-loader, esbuild-loader, swc-loader)
-              loader: "ts-loader",
-              options: {
-                transpileOnly: true,
-                compilerOptions: {
-                  module: "esnext",
-                  moduleResolution: "node",
-                  target: "es2020"
-                }
-              }
-            }
-          ]
+          name: "callback",
+          type: "() => void | CleanupFn",
+          required: true,
+          description: "Function to run after mount. May return a cleanup function."
+        },
+        {
+          name: "element",
+          type: "HTMLElement",
+          required: false,
+          description: "Optional element to observe; if provided, waits until it is connected."
         }
       ]
     },
-    plugins: [
-      // SibuJS plugin for optimizations
-      sibuWebpackPlugin({ devMode: isDev })
-    ],
-    optimization: {
-      minimize: !isDev,
-      // Enable tree-shaking
-      usedExports: true,
-      sideEffects: true,
-      // Split chunks for better caching
-      splitChunks: isDev ? false : {
-        chunks: "all",
-        cacheGroups: {
-          // Separate sibujs framework code into its own chunk (the package
-          // directory is `sibujs`; matching `sibu` never selected anything)
-          sibu: {
-            test: /[\\/]node_modules[\\/]sibujs[\\/]/,
-            name: "sibu",
-            chunks: "all",
-            priority: 20
-          },
-          // Separate other vendor code
-          vendor: {
-            test: /[\\/]node_modules[\\/]/,
-            name: "vendor",
-            chunks: "all",
-            priority: 10
-          }
+    {
+      name: "onUnmount",
+      description: "Runs a callback when the given element is removed from the DOM. Uses MutationObserver to watch for disconnection.",
+      props: [
+        {
+          name: "callback",
+          type: "() => void",
+          required: true,
+          description: "Function to run on unmount"
+        },
+        {
+          name: "element",
+          type: "HTMLElement",
+          required: true,
+          description: "The element to watch for removal"
         }
-      }
+      ]
     },
-    // Source maps
-    devtool: isDev ? "eval-cheap-module-source-map" : "source-map",
-    // Dev server configuration
-    devServer: isDev ? {
-      hot: true,
-      open: true,
-      port: 3e3,
-      historyApiFallback: true
-    } : void 0,
-    // Performance hints
-    performance: {
-      hints: isDev ? false : "warning",
-      maxEntrypointSize: 25e4,
-      maxAssetSize: 25e4
+    // ── Rendering ────────────────────────────────────────────────────
+    {
+      name: "mount",
+      description: "Mounts a root component into a DOM element. Returns an object with the mounted node and an unmount function.",
+      props: [
+        {
+          name: "component",
+          type: "(() => HTMLElement) | HTMLElement | Node",
+          required: true,
+          description: "Function returning HTMLElement, or an HTMLElement directly"
+        },
+        {
+          name: "container",
+          type: "HTMLElement",
+          required: true,
+          description: "Target DOM element to append the result"
+        }
+      ]
     },
-    // Cache for faster rebuilds
-    cache: {
-      type: "filesystem",
-      buildDependencies: {
-        config: []
-      }
+    {
+      name: "each",
+      description: "Renders a list of nodes efficiently with key-based diffing and LIS-based move minimization.",
+      props: [
+        {
+          name: "getArray",
+          type: "() => T[]",
+          required: true,
+          description: "A reactive getter returning an array"
+        },
+        {
+          name: "render",
+          type: "(item: T, index: number) => NodeChild",
+          required: true,
+          description: "A function that returns a NodeChild for each item"
+        },
+        {
+          name: "options",
+          type: "{ key: (item: T) => string | number }",
+          required: true,
+          description: "A key function for unique identity of items"
+        }
+      ]
+    },
+    {
+      name: "lazy",
+      description: "Enables code-splitting by deferring the import of a component until it is first rendered.",
+      props: [
+        {
+          name: "importFn",
+          type: "() => Promise<{ default: Component }>",
+          required: true,
+          description: "Dynamic import function returning { default: Component }"
+        }
+      ]
+    },
+    {
+      name: "Suspense",
+      description: "Provides a fallback UI while lazy or async nodes are loading.",
+      props: [
+        {
+          name: "nodes",
+          type: "() => HTMLElement",
+          required: true,
+          description: "Function that returns the async/lazy component"
+        },
+        {
+          name: "fallback",
+          type: "() => HTMLElement",
+          required: true,
+          description: "Function that returns the loading UI"
+        }
+      ]
+    },
+    // ── Context ──────────────────────────────────────────────────────
+    {
+      name: "context",
+      description: "Creates a context for dependency injection across component trees without prop drilling. Returns a Context object with provide, use, get, and set methods.",
+      props: [
+        {
+          name: "defaultValue",
+          type: "T",
+          required: true,
+          description: "The fallback value when no provider is found"
+        }
+      ]
+    },
+    // ── Dynamic Components ───────────────────────────────────────────
+    {
+      name: "DynamicComponent",
+      description: "Reactively switches between components based on a reactive getter returning a component name or function.",
+      props: [
+        {
+          name: "is",
+          type: "() => string | Component",
+          required: true,
+          description: "Reactive getter returning component name (string) or component function"
+        }
+      ]
+    },
+    {
+      name: "registerComponent",
+      description: "Registers a component by name for dynamic resolution via DynamicComponent or resolveComponent.",
+      props: [
+        {
+          name: "name",
+          type: "string",
+          required: true,
+          description: "Unique component identifier"
+        },
+        {
+          name: "component",
+          type: "() => HTMLElement",
+          required: true,
+          description: "The component function"
+        }
+      ]
+    },
+    // ── HTML Tag Factories ───────────────────────────────────────────
+    {
+      name: "div",
+      description: "Creates a reactive <div> element. Accepts TagProps including class, style, on, nodes, and arbitrary attributes.",
+      props: [
+        {
+          name: "props",
+          type: "TagProps",
+          required: false,
+          default: "{}",
+          description: "Props object with id, class, style, ref, nodes, on, and other attributes"
+        }
+      ],
+      events: [
+        {
+          name: "click",
+          description: "Fires when the element is clicked"
+        },
+        {
+          name: "input",
+          description: "Fires when user input is received"
+        }
+      ]
     }
-  };
-}
-
-// src/build/cdn.ts
-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 };
-}
-function umdWrapper(name, factory) {
-  const factoryStr = factory.toString();
-  return `(function (root, factory) {
-  if (typeof define === 'function' && define.amd) {
-    // AMD (RequireJS)
-    define([], factory);
-  } else if (typeof module === 'object' && module.exports) {
-    // CommonJS (Node.js)
-    module.exports = factory();
-  } else {
-    // Browser globals
-    root.${name} = factory();
-  }
-}(typeof self !== 'undefined' ? self : this, ${factoryStr}));`;
+  ];
 }
-var cdnUrls = {
-  /**
-   * Generate an unpkg CDN URL.
-   * @param version - Package version (defaults to 'latest')
-   */
-  unpkg: (version) => `https://unpkg.com/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
-  /**
-   * Generate a jsDelivr CDN URL.
-   * @param version - Package version (defaults to 'latest')
-   */
-  jsdelivr: (version) => `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
-  /**
-   * Generate a Skypack CDN URL (ESM-native).
-   * @param version - Package version (defaults to 'latest')
-   */
-  skypack: (version) => `https://cdn.skypack.dev/${PACKAGE_NAME}@${version || "latest"}`,
-  /**
-   * Generate a complete HTML script tag for including SibuJS from a CDN.
-   *
-   * @param provider - CDN provider to use (defaults to 'jsdelivr')
-   * @param version - Package version (defaults to 'latest')
-   * @returns An HTML script tag string
-   *
-   * @example
-   * ```ts
-   * cdnUrls.scriptTag('jsdelivr', '1.0.0')
-   * // => '<script src="https://cdn.jsdelivr.net/npm/sibujs@1.0.0/dist/cdn.global.js"></script>'
-   * ```
-   */
-  scriptTag: (provider = "jsdelivr", version) => {
-    const url = cdnUrls[provider](version);
-    if (provider === "skypack") {
-      return `<script type="module">
-import * as Sibu from '${url}';
-window.Sibu = Sibu;
-</script>`;
+function generateVSCodeSnippets() {
+  return {
+    "SibuJS Component": {
+      prefix: "sibu-component",
+      body: [
+        "import { div } from 'sibujs';",
+        "",
+        "export function ${1:ComponentName}(): HTMLElement {",
+        "	return div({",
+        "		class: '${2:component-class}',",
+        "		nodes: [",
+        "			${3:// nodes here}",
+        "		],",
+        "	});",
+        "}"
+      ],
+      description: "Create a basic SibuJS component"
+    },
+    "SibuJS Component with State": {
+      prefix: "sibu-component-state",
+      body: [
+        "import { div, span } from 'sibujs';",
+        "import { signal } from 'sibujs';",
+        "",
+        "export function ${1:ComponentName}(): HTMLElement {",
+        "	const [${2:value}, ${3:setValue}] = signal(${4:initialValue});",
+        "",
+        "	return div({",
+        "		class: '${5:component-class}',",
+        "		nodes: [",
+        "			() => span({ nodes: String(${2:value}()) }),",
+        "		],",
+        "	});",
+        "}"
+      ],
+      description: "Create a SibuJS component with reactive state"
+    },
+    "SibuJS signal": {
+      prefix: "sibu-state",
+      body: ["const [${1:value}, ${2:setValue}] = signal(${3:initialValue});"],
+      description: "Create a reactive state with signal"
+    },
+    "SibuJS effect": {
+      prefix: "sibu-effect",
+      body: ["const cleanup = effect(() => {", "	${1:// effect logic}", "});"],
+      description: "Create a reactive side effect with effect"
+    },
+    "SibuJS derived": {
+      prefix: "sibu-computed",
+      body: ["const ${1:computed} = derived(() => {", "	return ${2:// derived value};", "});"],
+      description: "Create a derived reactive value with derived"
+    },
+    "SibuJS watch": {
+      prefix: "sibu-watch",
+      body: [
+        "const teardown = watch(",
+        "	() => ${1:watchedValue}(),",
+        "	(newVal, oldVal) => {",
+        "		${2:// handle change}",
+        "	}",
+        ");"
+      ],
+      description: "Watch a reactive value for changes"
+    },
+    "SibuJS each": {
+      prefix: "sibu-each",
+      body: [
+        "each(",
+        "	() => ${1:items}(),",
+        "	(item) => {",
+        "		return ${2:div({ nodes: () => String(item()) })};",
+        "	},",
+        "	{ key: (item) => ${3:item.id} }",
+        ")"
+      ],
+      description: "Create a reactive list with each()"
+    },
+    "SibuJS Context": {
+      prefix: "sibu-context",
+      body: [
+        "const ${1:MyContext} = context(${2:defaultValue});",
+        "",
+        "// In provider component:",
+        "// ${1:MyContext}.provide(value);",
+        "",
+        "// In consumer component:",
+        "// const ${3:value} = ${1:MyContext}.use();"
+      ],
+      description: "Create a context for dependency injection"
+    },
+    "SibuJS store": {
+      prefix: "sibu-store",
+      body: [
+        "const [${1:store}, { setState: ${2:setStore}, reset, subscribe }] = store({",
+        "	${3:key}: ${4:value},",
+        "});"
+      ],
+      description: "Create a reactive global store"
+    },
+    "SibuJS Lazy Component": {
+      prefix: "sibu-lazy",
+      body: ["const ${1:LazyComponent} = lazy(() => import('./${2:ComponentPath}'));"],
+      description: "Create a lazy-loaded component"
+    },
+    "SibuJS Suspense": {
+      prefix: "sibu-suspense",
+      body: [
+        "Suspense({",
+        "	nodes: () => ${1:LazyComponent}(),",
+        "	fallback: () => div({ nodes: '${2:Loading...}' }),",
+        "})"
+      ],
+      description: "Wrap a lazy component with a loading fallback"
+    },
+    "SibuJS onMount": {
+      prefix: "sibu-mount",
+      body: ["onMount(() => {", "	${1:// runs after component enters the DOM}", "});"],
+      description: "Schedule a callback to run after mount"
+    },
+    "SibuJS onUnmount": {
+      prefix: "sibu-unmount",
+      body: ["onUnmount(() => {", "	${1:// cleanup when removed from DOM}", "}, ${2:element});"],
+      description: "Schedule a callback to run on unmount"
+    },
+    "SibuJS Event Handler": {
+      prefix: "sibu-event",
+      body: [
+        "div({",
+        "	on: {",
+        "		${1:click}: (e) => {",
+        "			${2:// handle event}",
+        "		},",
+        "	},",
+        "	nodes: '${3:Click me}',",
+        "})"
+      ],
+      description: "Create an element with event handlers"
+    },
+    "SibuJS Form": {
+      prefix: "sibu-form",
+      body: [
+        "const form = form({",
+        "	${1:fieldName}: {",
+        "		initial: '${2:}',",
+        "		validators: [",
+        "			(value) => !value ? '${3:Required}' : null,",
+        "		],",
+        "	},",
+        "});"
+      ],
+      description: "Create a reactive form with validation"
     }
-    return `<script src="${url}"></script>`;
-  }
-};
-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`
   };
-  for (const entry of SUBPATH_ENTRIES) {
-    imports[`${PACKAGE_NAME}/${entry}`] = `${base}/dist/${entry}.js`;
-  }
+}
+function generateLanguageConfig() {
   return {
-    imports,
-    /**
-     * Serialize the import map to a JSON string.
-     */
-    toJSON() {
-      return JSON.stringify({ imports }, null, 2);
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
     },
-    /**
-     * Generate a complete `<script type="importmap">` tag.
-     */
-    toScriptTag() {
-      return `<script type="importmap">
-${JSON.stringify({ imports }, null, 2)}
-</script>`;
-    }
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' },
+      { open: "`", close: "`" }
+    ]
   };
 }
-
-// src/build/declarations.ts
-var RECOMMENDED_OPTIONS = {
-  target: "ES2020",
-  module: "ESNext",
-  moduleResolution: "bundler",
-  strict: true,
-  esModuleInterop: true,
-  skipLibCheck: true,
-  declaration: true,
-  declarationMap: true,
-  sourceMap: true,
-  jsx: "preserve",
-  lib: ["ES2020", "DOM", "DOM.Iterable"],
-  isolatedModules: true,
-  resolveJsonModule: true,
-  allowSyntheticDefaultImports: true,
-  forceConsistentCasingInFileNames: true,
-  noUncheckedIndexedAccess: true,
-  noEmit: false
-};
-var REQUIRED_OPTIONS = {
-  strict: {
-    value: true,
-    reason: "SibuJS relies on strict type checking for safe reactive state handling."
-  },
-  esModuleInterop: {
-    value: true,
-    reason: "Required for correct ESM interop with SibuJS module exports."
-  },
-  moduleResolution: {
-    value: ["node", "bundler", "node16", "nodenext"],
-    reason: "SibuJS requires a module resolution strategy that supports package.json exports."
-  }
-};
-var SUGGESTED_OPTIONS = {
-  declarationMap: {
-    value: true,
-    reason: 'Enables "Go to Definition" to navigate to SibuJS source files in your IDE.'
-  },
-  sourceMap: {
-    value: true,
-    reason: "Enables source map debugging for SibuJS components."
-  },
-  noUncheckedIndexedAccess: {
-    value: true,
-    reason: "Improves type safety when accessing reactive state objects."
-  },
-  isolatedModules: {
-    value: true,
-    reason: "Required for compatibility with esbuild/swc transpilers used by Vite."
-  }
-};
-function generateTsConfig(options) {
-  const { target = "ES2020", outDir = "dist", declarationMap = true, paths } = options || {};
-  const compilerOptions = {
-    ...RECOMMENDED_OPTIONS,
-    target,
-    outDir,
-    declarationMap
-  };
-  if (paths && Object.keys(paths).length > 0) {
-    compilerOptions.baseUrl = ".";
-    compilerOptions.paths = {
-      // Default sibujs alias
-      sibujs: ["node_modules/sibujs/dist/index.d.ts"],
-      "sibujs/*": ["node_modules/sibujs/dist/*"],
-      // User-provided paths
-      ...paths
-    };
-  }
+function generateTypeStubs() {
   return {
-    compilerOptions,
-    include: ["src/**/*.ts", "src/**/*.tsx"],
-    exclude: ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+    signal: ["declare function signal<T>(initial: T): [() => T, (next: T | ((prev: T) => T)) => void];"].join("\n"),
+    effect: ["declare function effect(effectFn: () => void): () => void;"].join("\n"),
+    derived: ["declare function derived<T>(getter: () => T): () => T;"].join("\n"),
+    ref: [
+      "interface Ref<T> { current: T; }",
+      "declare function ref<T>(initial: T): Ref<T>;",
+      "declare function ref<T = undefined>(): Ref<T | undefined>;"
+    ].join("\n"),
+    watch: [
+      "declare function watch<T>(getter: () => T, callback: (value: T, prev: T | undefined) => void): () => void;"
+    ].join("\n"),
+    store: [
+      "interface StoreActions<T> {",
+      "  setState: (patch: Partial<T> | ((state: T) => T)) => void;",
+      "  reset: () => void;",
+      "  subscribe: (callback: (state: T) => void) => () => void;",
+      "  subscribeKey: <K extends keyof T>(key: K, callback: (value: T[K], prev: T[K]) => void) => () => void;",
+      "  getSnapshot: () => T;",
+      "}",
+      "declare function store<T extends object>(initialState: T): [{ readonly [K in keyof T]: T[K] }, StoreActions<T>];"
+    ].join("\n"),
+    mount: [
+      "declare function mount(component: (() => HTMLElement) | HTMLElement | Node, container: HTMLElement | null): { node: Node; unmount: () => void };"
+    ].join("\n"),
+    each: [
+      "declare function each<T>(getArray: () => T[], render: (item: T, index: number) => NodeChild, options: { key: (item: T) => string | number }): Comment;"
+    ].join("\n"),
+    onMount: ["declare function onMount(callback: () => void | (() => void), element?: HTMLElement): void;"].join("\n"),
+    onUnmount: ["declare function onUnmount(callback: () => void, element: HTMLElement): void;"].join("\n"),
+    context: [
+      "interface Context<T> {",
+      "  provide(value: T): void;",
+      "  use(): () => T;",
+      "  get(): T;",
+      "  set(value: T): void;",
+      "}",
+      "declare function context<T>(defaultValue: T): Context<T>;"
+    ].join("\n"),
+    lazy: ["declare function lazy(importFn: () => Promise<{ default: () => HTMLElement }>): () => HTMLElement;"].join(
+      "\n"
+    ),
+    Suspense: [
+      "interface SuspenseProps { nodes: () => HTMLElement; fallback: () => HTMLElement; }",
+      "declare function Suspense(props: SuspenseProps): HTMLElement;"
+    ].join("\n"),
+    tagFactory: [
+      "interface TagProps {",
+      "  id?: string;",
+      "  class?: string | (() => string) | Record<string, boolean | (() => boolean)>;",
+      "  style?: Record<string, string | number | (() => string | number)> | string | (() => string);",
+      "  ref?: { current: unknown };",
+      "  nodes?: NodeChildren;",
+      "  on?: Record<string, (ev: Event) => void>;",
+      "  [attr: string]: unknown;",
+      "}",
+      "declare function tagFactory(tag: string, ns?: string): (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;"
+    ].join("\n"),
+    DynamicComponent: ["declare function DynamicComponent(is: () => string | (() => HTMLElement)): HTMLElement;"].join(
+      "\n"
+    ),
+    registerComponent: ["declare function registerComponent(name: string, component: () => HTMLElement): void;"].join(
+      "\n"
+    )
   };
 }
-function validateTsConfig(config) {
-  const warnings = [];
-  const suggestions = [];
-  const compilerOptions = config.compilerOptions || {};
-  for (const [option, requirement] of Object.entries(REQUIRED_OPTIONS)) {
-    const currentValue = compilerOptions[option];
-    if (Array.isArray(requirement.value)) {
-      if (currentValue === void 0) {
-        warnings.push(
-          `Missing required option "${option}". ${requirement.reason} Recommended value: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
-        );
-      } else if (!requirement.value.includes(currentValue)) {
-        warnings.push(
-          `Option "${option}" is set to "${currentValue}" which may not be compatible with SibuJS. ${requirement.reason} Recommended: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
-        );
-      }
-    } else {
-      if (currentValue === void 0) {
-        warnings.push(
-          `Missing required option "${option}". ${requirement.reason} Recommended value: ${JSON.stringify(requirement.value)}.`
-        );
-      } else if (currentValue !== requirement.value) {
-        warnings.push(
-          `Option "${option}" is set to ${JSON.stringify(currentValue)} but SibuJS recommends ${JSON.stringify(requirement.value)}. ${requirement.reason}`
-        );
-      }
-    }
-  }
-  for (const [option, suggestion] of Object.entries(SUGGESTED_OPTIONS)) {
-    const currentValue = compilerOptions[option];
-    if (currentValue === void 0 || currentValue !== suggestion.value) {
-      suggestions.push(`Consider setting "${option}" to ${JSON.stringify(suggestion.value)}. ${suggestion.reason}`);
-    }
-  }
-  const target = typeof compilerOptions.target === "string" ? compilerOptions.target.toUpperCase() : void 0;
-  if (target) {
-    const es2020Plus = ["ES2020", "ES2021", "ES2022", "ES2023", "ES2024", "ESNEXT"];
-    if (!es2020Plus.includes(target)) {
-      warnings.push(
-        `Target "${target}" may not support all features used by SibuJS. Recommended: "ES2020" or newer. SibuJS uses optional chaining, nullish coalescing, and other ES2020+ features.`
-      );
-    }
-  }
-  const module = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
-  if (module && !["esnext", "es2020", "es2022", "node16", "nodenext"].includes(module)) {
-    suggestions.push(
-      `Module "${compilerOptions.module}" may not provide optimal results with SibuJS. Consider using "ESNext" for best tree-shaking and bundle optimization.`
-    );
-  }
-  const lib = compilerOptions.lib;
-  if (Array.isArray(lib)) {
-    const hasDom = lib.some((l) => l.toUpperCase() === "DOM" || l.toUpperCase() === "DOM.ITERABLE");
-    if (!hasDom) {
-      suggestions.push(
-        'The "lib" array does not include "DOM". SibuJS requires DOM types for component rendering. Add "DOM" and "DOM.Iterable" to your lib array.'
-      );
-    }
+
+// src/build/linting.ts
+function getLineNumber(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source[i] === "\n") line++;
   }
-  if (Array.isArray(config.include)) {
-    const includesTs = config.include.some(
-      (pattern) => pattern.includes(".ts") || pattern.includes("*")
-    );
-    if (!includesTs) {
-      suggestions.push(
-        'Your "include" patterns may not capture TypeScript files. Ensure patterns like "src/**/*.ts" are included.'
-      );
-    }
+  return line;
+}
+function getColumnNumber(source, index) {
+  let col = 1;
+  for (let i = index - 1; i >= 0; i--) {
+    if (source[i] === "\n") break;
+    col++;
   }
-  return {
-    valid: warnings.length === 0,
-    warnings,
-    suggestions
-  };
-}
-
-// src/build/analyzer.ts
-var moduleSizes = {
-  // Core modules
-  "core/html": 1800,
-  "core/mount": 120,
-  "core/each": 450,
-  "core/slots": 200,
-  "core/fragment": 180,
-  "core/catch": 280,
-  "core/portal": 350,
-  "core/directives": 520,
-  "core/dynamic": 380,
-  "core/head": 300,
-  "core/ssr": 1200,
-  "core/customElement": 650,
-  "core/scopedStyle": 480,
-  "core/domRecycler": 420,
-  "core/bundleOptimize": 200,
-  "core/compiled": 350,
-  "core/normalize": 280,
-  "core/reactiveAttr": 320,
-  "core/componentProps": 400,
-  "core/contracts": 350,
-  "core/worker": 550,
-  "core/wasm": 480,
-  "core/concurrent": 600,
-  "core/microfrontend": 700,
-  "core/chunkLoader": 450,
-  "core/versioning": 300,
-  "core/ecosystem": 250,
-  // Signals
-  "core/signal": 280,
-  "core/effect": 350,
-  "core/derived": 250,
-  "core/watch": 300,
-  "core/store": 380,
-  "core/ref": 150,
-  "core/array": 420,
-  "core/deepSignal": 500,
-  "core/lifecycle": 300,
-  "core/context": 350,
-  "core/persist": 400,
-  "core/hoc": 280,
-  "core/transition": 600,
-  "core/form": 750,
-  "core/globalStore": 450,
-  "core/machine": 550,
-  "core/optimistic": 380,
-  "core/timeTravel": 500,
-  "core/scheduler": 350,
-  "core/plugin": 300,
-  "core/virtualList": 800,
-  "core/intersection": 350,
-  "core/inputMask": 450,
-  "core/a11y": 500,
-  "core/debug": 400,
-  "core/serviceWorker": 350,
-  "core/composable": 280,
-  // Reactivity
-  "reactivity/signal": 100,
-  "reactivity/track": 250,
-  "reactivity/batch": 200,
-  "reactivity/bindAttribute": 300,
-  "reactivity/bindChildNode": 250,
-  "reactivity/bindTextNode": 200,
-  // Components
-  "components/ErrorBoundary": 350,
-  "components/Loading": 250,
-  // Plugins
-  "plugins/i18n": 600,
-  "plugins/router": 900,
-  "plugins/routerSSR": 500,
-  // Build utilities
-  "build/vite": 800,
-  "build/webpack": 750,
-  "build/cdn": 400,
-  "build/declarations": 500,
-  "build/analyzer": 600,
-  // Testing
-  "testing/index": 700,
-  "testing/e2e": 500
-};
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-function analyzeBundle(modules) {
-  const sizes = {};
-  let totalSize = 0;
-  for (const [name, source] of Object.entries(modules)) {
-    let byteLength;
-    if (typeof TextEncoder !== "undefined") {
-      byteLength = new TextEncoder().encode(source).length;
-    } else {
-      byteLength = source.length;
-    }
-    sizes[name] = byteLength;
-    totalSize += byteLength;
-  }
-  const sorted = Object.entries(sizes).map(([name, size]) => ({
-    name,
-    size,
-    percentage: totalSize > 0 ? size / totalSize * 100 : 0
-  })).sort((a, b) => b.size - a.size);
-  return {
-    totalSize,
-    moduleSizes: sizes,
-    sorted,
-    report() {
-      const lines = [
-        "=== SibuJS Bundle Analysis ===",
-        "",
-        `Total size: ${formatBytes(totalSize)}`,
-        `Modules: ${sorted.length}`,
-        "",
-        "Module breakdown:",
-        "-".repeat(60)
-      ];
-      for (const entry of sorted) {
-        const sizeStr = formatBytes(entry.size).padStart(10);
-        const pctStr = `${entry.percentage.toFixed(1)}%`.padStart(6);
-        const bar = generateBar(entry.percentage, 20);
-        lines.push(`  ${sizeStr}  ${pctStr}  ${bar}  ${entry.name}`);
-      }
-      lines.push("-".repeat(60));
-      return lines.join("\n");
-    }
-  };
-}
-function generateBar(percentage, width) {
-  const filled = Math.round(percentage / 100 * width);
-  const empty = width - filled;
-  return `[${"#".repeat(filled)}${".".repeat(empty)}]`;
-}
-function estimateImportSize(imports) {
-  const breakdown = {};
-  let estimated = 0;
-  const implicitDeps = ["reactivity/signal", "reactivity/track"];
-  const allImports = [.../* @__PURE__ */ new Set([...implicitDeps, ...imports])];
-  for (const importPath of allImports) {
-    const size = moduleSizes[importPath];
-    if (size !== void 0) {
-      breakdown[importPath] = size;
-      estimated += size;
-    } else {
-      const avgSize = 350;
-      breakdown[importPath] = avgSize;
-      estimated += avgSize;
-    }
-  }
-  const sortedEntries = Object.entries(breakdown).sort(([, a], [, b]) => b - a);
-  const lines = [`Estimated bundle size: ${formatBytes(estimated)} (minified + gzipped)`, ""];
-  for (const [modulePath, size] of sortedEntries) {
-    const known = moduleSizes[modulePath] !== void 0;
-    lines.push(`  ${modulePath}: ${formatBytes(size)}${known ? "" : " (estimated)"}`);
-  }
-  if (imports.length > 0) {
-    lines.push("");
-    lines.push("Note: Actual sizes may vary based on tree-shaking and build configuration.");
-    lines.push("Implicit dependencies (reactivity/signal, reactivity/track) are included.");
-  }
-  return {
-    estimated,
-    breakdown,
-    formatted: lines.join("\n")
-  };
-}
-
-// src/build/linting.ts
-function getLineNumber(source, index) {
-  let line = 1;
-  for (let i = 0; i < index && i < source.length; i++) {
-    if (source[i] === "\n") line++;
-  }
-  return line;
-}
-function getColumnNumber(source, index) {
-  let col = 1;
-  for (let i = index - 1; i >= 0; i--) {
-    if (source[i] === "\n") break;
-    col++;
-  }
-  return col;
+  return col;
 }
 var lintRules = {
   /** Detect signal inside loops or conditionals */
@@ -2610,636 +2522,1075 @@ function generateEslintConfig(options) {
   };
 }
 
-// src/build/ide.ts
-function getComponentMetadata() {
-  return [
-    // ── Reactive Primitives ──────────────────────────────────────────
-    {
-      name: "signal",
-      description: "Creates a reactive signal that holds a value. Returns a [getter, setter] tuple. The getter registers reactive dependencies when called.",
-      props: [
-        {
-          name: "initial",
-          type: "T",
-          required: true,
-          description: "The initial value of the state"
-        }
-      ]
-    },
-    {
-      name: "effect",
-      description: "Runs a side effect function immediately and re-runs it whenever any reactive dependency changes. Returns a cleanup function.",
-      props: [
-        {
-          name: "effectFn",
-          type: "() => void",
-          required: true,
-          description: "The effect function to run. It is tracked for reactive dependencies."
-        }
-      ]
-    },
-    {
-      name: "derived",
-      description: "Creates a derived reactive signal whose value updates automatically when dependencies change. Returns a getter function.",
-      props: [
-        {
-          name: "getter",
-          type: "() => T",
-          required: true,
-          description: "Function returning the computed value based on reactive signals"
-        }
-      ]
-    },
-    {
-      name: "ref",
-      description: "Creates a mutable reference object that persists across renders. Updating a ref does NOT trigger re-renders.",
-      props: [
-        {
-          name: "initial",
-          type: "T",
-          required: false,
-          default: "undefined",
-          description: "Optional initial value for the ref"
-        }
-      ]
-    },
-    {
-      name: "watch",
-      description: "Watches a reactive getter and calls a callback with (newValue, oldValue) when the watched value changes. Returns a teardown function.",
-      props: [
-        {
-          name: "getter",
-          type: "() => T",
-          required: true,
-          description: "Function that returns the value to watch"
-        },
-        {
-          name: "callback",
-          type: "(value: T, prev: T | undefined) => void",
-          required: true,
-          description: "Function called when the watched value changes"
-        }
-      ]
-    },
-    {
-      name: "store",
-      description: "Creates a global store with reactive properties and subscription support. Returns a [store, actions] tuple.",
-      props: [
-        {
-          name: "initialState",
-          type: "T extends object",
-          required: true,
-          description: "Initial state object for the store"
-        }
-      ]
-    },
-    // ── Lifecycle ────────────────────────────────────────────────────
-    {
-      name: "onMount",
-      description: "Runs a callback once the component element has been inserted into the DOM. Uses queueMicrotask for deferred execution.",
-      props: [
-        {
-          name: "callback",
-          type: "() => void | CleanupFn",
-          required: true,
-          description: "Function to run after mount. May return a cleanup function."
-        },
-        {
-          name: "element",
-          type: "HTMLElement",
-          required: false,
-          description: "Optional element to observe; if provided, waits until it is connected."
-        }
-      ]
-    },
-    {
-      name: "onUnmount",
-      description: "Runs a callback when the given element is removed from the DOM. Uses MutationObserver to watch for disconnection.",
-      props: [
-        {
-          name: "callback",
-          type: "() => void",
-          required: true,
-          description: "Function to run on unmount"
-        },
-        {
-          name: "element",
-          type: "HTMLElement",
-          required: true,
-          description: "The element to watch for removal"
+// src/build/prerender.ts
+var PRERENDER_CHILD_ENV = "SIBU_PRERENDER_CHILD";
+var MODULE_SCRIPT = /<script\b[^>]*\btype\s*=\s*["']module["'][^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/i;
+var MODULE_SCRIPT_SRC_FIRST = /<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*\btype\s*=\s*["']module["'][^>]*>/i;
+function findEntryInHtml(html) {
+  const m = MODULE_SCRIPT.exec(html) ?? MODULE_SCRIPT_SRC_FIRST.exec(html);
+  return m ? m[1] : null;
+}
+function outputFileFor(route) {
+  if (route.output) {
+    const output = route.output;
+    if (/^[A-Za-z]:/.test(output) || output.includes("\0")) {
+      throw new Error(`[sibu prerender] unsafe output "${output}": must be a path relative to the output dir`);
+    }
+    const segments2 = output.split(/[\\/]+/).filter(Boolean);
+    if (segments2.length === 0 || segments2.some((s) => s === "." || s === "..")) {
+      throw new Error(`[sibu prerender] unsafe output "${output}": "." and ".." segments are not allowed`);
+    }
+    return segments2.join("/");
+  }
+  const pathname = route.path.split(/[?#]/)[0];
+  if (!pathname.startsWith("/")) throw new Error(`[sibu prerender] route "${route.path}" must start with "/"`);
+  const segments = pathname.split("/").filter(Boolean).map((raw) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(raw);
+    } catch {
+      throw new Error(
+        `[sibu prerender] route "${route.path}" has malformed percent-encoding in "${raw}"; encode a literal % as %25.`
+      );
+    }
+    if (decoded === "." || decoded === ".." || /[\\/\0]/.test(decoded)) {
+      throw new Error(
+        `[sibu prerender] unsafe route "${route.path}": segment "${raw}" decodes to "${decoded}", which could leave the output dir (".", "..", or a path separator).`
+      );
+    }
+    return decoded;
+  });
+  return [...segments, "index.html"].join("/");
+}
+function resolveInsideOutDir(path, outDir, file) {
+  const root = path.resolve(outDir);
+  const target = path.resolve(root, file);
+  const rel = path.relative(root, target);
+  const escapes = rel === "" || rel === ".." || /^\.\.[\\/]/.test(rel) || path.isAbsolute(rel);
+  if (escapes) throw new Error(`[sibu prerender] refusing to write "${file}": it resolves outside ${root}`);
+  return target;
+}
+async function prerender(options, ctx) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const { pathToFileURL } = await import("url");
+  const { createRequire } = await import("module");
+  const routes = options.routes.map((r) => typeof r === "string" ? { path: r } : r);
+  if (routes.length === 0) return [];
+  const planned = routes.map((route) => {
+    const file = outputFileFor(route);
+    resolveInsideOutDir(path, ctx.outDir, file);
+    return { route, file };
+  });
+  const origin = (options.origin ?? "http://localhost").replace(/\/+$/, "");
+  const timeout = options.timeout ?? 15e3;
+  const settle = options.settle ?? 50;
+  const templatePath = path.join(ctx.outDir, "index.html");
+  const template = await fs.readFile(templatePath, "utf8");
+  let entry = options.entry;
+  if (!entry) {
+    const sourceHtml = await fs.readFile(path.join(ctx.root, "index.html"), "utf8");
+    entry = findEntryInHtml(sourceHtml) ?? void 0;
+    if (!entry) {
+      throw new Error("[sibu prerender] could not find the client entry in index.html; pass `prerender.entry`.");
+    }
+  }
+  const entryAbs = path.resolve(ctx.root, entry.replace(/^\//, ""));
+  const requireFromApp = createRequire(path.join(ctx.root, "package.json"));
+  let jsdomPath;
+  try {
+    jsdomPath = requireFromApp.resolve("jsdom");
+  } catch {
+    throw new Error("[sibu prerender] needs jsdom to render routes. Install it: npm i -D jsdom");
+  }
+  const tmpDir = path.join(ctx.outDir, ".sibu-prerender");
+  await fs.rm(tmpDir, { recursive: true, force: true });
+  const viteBuild = await loadViteBuild(requireFromApp, fs, path, pathToFileURL);
+  const prev = process.env[PRERENDER_CHILD_ENV];
+  process.env[PRERENDER_CHILD_ENV] = "1";
+  try {
+    await viteBuild({
+      configFile: ctx.configFile,
+      root: ctx.root,
+      mode: ctx.mode,
+      logLevel: "warn",
+      build: {
+        ssr: entryAbs,
+        outDir: tmpDir,
+        emptyOutDir: true,
+        copyPublicDir: false,
+        minify: false,
+        sourcemap: false,
+        rollupOptions: { output: { format: "es", entryFileNames: "entry.mjs" } }
+      }
+    });
+  } finally {
+    if (prev === void 0) delete process.env[PRERENDER_CHILD_ENV];
+    else process.env[PRERENDER_CHILD_ENV] = prev;
+  }
+  await fs.writeFile(path.join(tmpDir, "package.json"), '{ "type": "module" }\n', "utf8");
+  const workerFile = path.join(tmpDir, "render-worker.mjs");
+  await fs.writeFile(workerFile, WORKER_SOURCE, "utf8");
+  const entryUrl = pathToFileURL(path.join(tmpDir, "entry.mjs")).href;
+  const jsdomUrl = pathToFileURL(jsdomPath).href;
+  if (options.shell !== false) {
+    await fs.writeFile(path.join(ctx.outDir, options.shell ?? "200.html"), template, "utf8");
+  }
+  const results = [];
+  const queue = [...planned];
+  const concurrency = Math.max(1, options.concurrency ?? 4);
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+        for (let job = queue.shift(); job; job = queue.shift()) {
+          const { route, file } = job;
+          const started = Date.now();
+          const html = await renderInWorker(workerFile, {
+            entryUrl,
+            jsdomUrl,
+            html: template,
+            url: origin + route.path,
+            route: route.path,
+            timeout,
+            settle
+          });
+          const target = resolveInsideOutDir(path, ctx.outDir, file);
+          await fs.mkdir(path.dirname(target), { recursive: true });
+          await fs.writeFile(target, html, "utf8");
+          results.push({ route: route.path, file, ms: Date.now() - started });
         }
-      ]
-    },
-    // ── Rendering ────────────────────────────────────────────────────
-    {
-      name: "mount",
-      description: "Mounts a root component into a DOM element. Returns an object with the mounted node and an unmount function.",
-      props: [
-        {
-          name: "component",
-          type: "(() => HTMLElement) | HTMLElement | Node",
-          required: true,
-          description: "Function returning HTMLElement, or an HTMLElement directly"
-        },
-        {
-          name: "container",
-          type: "HTMLElement",
-          required: true,
-          description: "Target DOM element to append the result"
-        }
-      ]
-    },
-    {
-      name: "each",
-      description: "Renders a list of nodes efficiently with key-based diffing and LIS-based move minimization.",
-      props: [
-        {
-          name: "getArray",
-          type: "() => T[]",
-          required: true,
-          description: "A reactive getter returning an array"
-        },
-        {
-          name: "render",
-          type: "(item: T, index: number) => NodeChild",
-          required: true,
-          description: "A function that returns a NodeChild for each item"
-        },
-        {
-          name: "options",
-          type: "{ key: (item: T) => string | number }",
-          required: true,
-          description: "A key function for unique identity of items"
-        }
-      ]
-    },
-    {
-      name: "lazy",
-      description: "Enables code-splitting by deferring the import of a component until it is first rendered.",
-      props: [
-        {
-          name: "importFn",
-          type: "() => Promise<{ default: Component }>",
-          required: true,
-          description: "Dynamic import function returning { default: Component }"
-        }
-      ]
-    },
-    {
-      name: "Suspense",
-      description: "Provides a fallback UI while lazy or async nodes are loading.",
-      props: [
-        {
-          name: "nodes",
-          type: "() => HTMLElement",
-          required: true,
-          description: "Function that returns the async/lazy component"
-        },
-        {
-          name: "fallback",
-          type: "() => HTMLElement",
-          required: true,
-          description: "Function that returns the loading UI"
-        }
-      ]
-    },
-    // ── Context ──────────────────────────────────────────────────────
-    {
-      name: "context",
-      description: "Creates a context for dependency injection across component trees without prop drilling. Returns a Context object with provide, use, get, and set methods.",
-      props: [
-        {
-          name: "defaultValue",
-          type: "T",
-          required: true,
-          description: "The fallback value when no provider is found"
-        }
-      ]
-    },
-    // ── Dynamic Components ───────────────────────────────────────────
-    {
-      name: "DynamicComponent",
-      description: "Reactively switches between components based on a reactive getter returning a component name or function.",
-      props: [
-        {
-          name: "is",
-          type: "() => string | Component",
-          required: true,
-          description: "Reactive getter returning component name (string) or component function"
-        }
-      ]
-    },
-    {
-      name: "registerComponent",
-      description: "Registers a component by name for dynamic resolution via DynamicComponent or resolveComponent.",
-      props: [
-        {
-          name: "name",
-          type: "string",
-          required: true,
-          description: "Unique component identifier"
-        },
-        {
-          name: "component",
-          type: "() => HTMLElement",
-          required: true,
-          description: "The component function"
-        }
-      ]
-    },
-    // ── HTML Tag Factories ───────────────────────────────────────────
-    {
-      name: "div",
-      description: "Creates a reactive <div> element. Accepts TagProps including class, style, on, nodes, and arbitrary attributes.",
-      props: [
-        {
-          name: "props",
-          type: "TagProps",
-          required: false,
-          default: "{}",
-          description: "Props object with id, class, style, ref, nodes, on, and other attributes"
-        }
-      ],
-      events: [
-        {
-          name: "click",
-          description: "Fires when the element is clicked"
-        },
-        {
-          name: "input",
-          description: "Fires when user input is received"
-        }
-      ]
+      })
+    );
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+  return results;
+}
+function esmEntryOf(entry) {
+  if (typeof entry === "string") return entry;
+  if (entry === null || typeof entry !== "object") return void 0;
+  const conditions = entry;
+  for (const key of ["import", "module-sync", "default"]) {
+    const found = esmEntryOf(conditions[key]);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function loadViteBuild(requireFromApp, fs, path, pathToFileURL) {
+  let resolved;
+  try {
+    resolved = requireFromApp.resolve("vite");
+  } catch {
+    throw new Error("[sibu prerender] needs Vite to build the entry for Node, and could not resolve it from the app.");
+  }
+  let url = pathToFileURL(resolved).href;
+  try {
+    const pkgPath = requireFromApp.resolve("vite/package.json");
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+    const entry = esmEntryOf(pkg.exports?.["."]);
+    if (entry) url = pathToFileURL(path.join(path.dirname(pkgPath), entry)).href;
+  } catch {
+  }
+  const mod = await import(url);
+  const build = mod.build ?? mod.default?.build;
+  if (typeof build !== "function") {
+    throw new Error(`[sibu prerender] the Vite module at ${url} has no build() function.`);
+  }
+  return build;
+}
+async function renderInWorker(workerFile, input) {
+  const { Worker } = await import("worker_threads");
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(workerFile, { workerData: input });
+    let done = false;
+    const finish = (fn) => {
+      if (done) return;
+      done = true;
+      fn();
+      void worker.terminate();
+    };
+    const timer = setTimeout(
+      () => finish(() => reject(new Error(`[sibu prerender] ${input.route}: worker did not respond`))),
+      input.timeout + 5e3
+    );
+    worker.once("message", (msg) => {
+      clearTimeout(timer);
+      if (typeof msg.html === "string") finish(() => resolve(msg.html));
+      else finish(() => reject(new Error(`[sibu prerender] ${input.route}: ${msg.error}`)));
+    });
+    worker.once("error", (err) => {
+      clearTimeout(timer);
+      finish(() => reject(new Error(`[sibu prerender] ${input.route}: ${err instanceof Error ? err.stack : err}`)));
+    });
+    worker.once("exit", (code) => {
+      clearTimeout(timer);
+      finish(() => reject(new Error(`[sibu prerender] ${input.route}: worker exited (${code}) before rendering`)));
+    });
+  });
+}
+var WORKER_SOURCE = `
+import { parentPort, workerData } from "node:worker_threads";
+
+const { entryUrl, jsdomUrl, html, url, route, timeout, settle } = workerData;
+const fail = (err) => parentPort.postMessage({ error: err instanceof Error ? (err.stack || err.message) : String(err) });
+
+try {
+  const jsdom = await import(jsdomUrl);
+  const JSDOM = jsdom.JSDOM ?? jsdom.default.JSDOM;
+  const dom = new JSDOM(html, { url, pretendToBeVisual: true });
+  const win = dom.window;
+  // Read before the app runs: the router may replace it with the route title.
+  const templateTitle = win.document.title;
+
+  // Register the document as THE global DOM. Node already has a few of these
+  // names (Event, EventTarget, \u2026); the DOM's own must win, or an event the app
+  // builds could not be dispatched on a DOM node.
+  const FORCE = new Set(["Event", "EventTarget", "CustomEvent", "MessageEvent", "DOMException"]);
+  for (const key of Object.getOwnPropertyNames(win)) {
+    if (key in globalThis && !FORCE.has(key)) continue;
+    try { globalThis[key] = win[key]; } catch {}
+  }
+  globalThis.window = win;
+  globalThis.self = win;
+  globalThis.document = win.document;
+
+  let lastActivity = Date.now();
+  const pending = new Set();
+  const errors = [];
+  const track = (p) => {
+    const tracked = Promise.resolve(p).then(() => {}, () => {});
+    pending.add(tracked);
+    tracked.finally(() => { pending.delete(tracked); lastActivity = Date.now(); });
+  };
+
+  // Hold serialization while \`p\` is pending, WITHOUT handling it: the caller
+  // receives a promise that settles exactly as \`p\` does, so a rejection the
+  // app handles behaves normally and one it ignores still reaches the
+  // unhandledRejection listener below (attaching a handler to \`p\` itself
+  // would silently mark it handled).
+  const observe = (p) => {
+    let release;
+    const tracked = new Promise((r) => { release = r; });
+    pending.add(tracked);
+    tracked.finally(() => { pending.delete(tracked); lastActivity = Date.now(); });
+    return Promise.resolve(p).then(
+      (value) => { release(); return value; },
+      (error) => { release(); throw error; },
+    );
+  };
+
+  // Every fetch holds serialization until it settles; relative URLs resolve
+  // against the route's URL, as they would in the browser.
+  const nodeFetch = globalThis.fetch;
+  if (typeof nodeFetch === "function") {
+    const wrapped = (input, init) => {
+      const target = typeof input === "string" || input instanceof URL ? new URL(String(input), url) : input;
+      return observe(nodeFetch(target, init));
+    };
+    globalThis.fetch = wrapped;
+    win.fetch = wrapped;
+  }
+
+  // A fetch settles when the HEADERS arrive; the data the page renders comes
+  // from a body reader that may still be waiting for the rest of the response.
+  // Each reader call is held like the fetch itself. Patched on the prototype \u2014
+  // this thread exists only to render one route \u2014 so clones, and Responses the
+  // app builds itself, are covered, and \`this\` / brand checks are the native
+  // ones. Bodies nobody reads are never touched, so an unused or long-lived
+  // body does not hold the page. Reading \`response.body\` directly as a stream
+  // is NOT held (a stream may never end); wrap such a read in prerenderWait().
+  const ResponseCtor = globalThis.Response;
+  if (typeof ResponseCtor === "function") {
+    const proto = ResponseCtor.prototype;
+    for (const name of ["arrayBuffer", "blob", "bytes", "formData", "json", "text"]) {
+      const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+      const original = descriptor?.value;
+      if (typeof original !== "function") continue;
+      Object.defineProperty(proto, name, {
+        ...descriptor,
+        value: {
+          // A method-shorthand keeps the native name and is not constructible.
+          [name](...args) {
+            return observe(Reflect.apply(original, this, args));
+          },
+        }[name],
+      });
     }
-  ];
+  }
+
+  globalThis[Symbol.for("sibujs.prerender.v1")] = { route, wait: track };
+
+  new win.MutationObserver(() => { lastActivity = Date.now(); }).observe(win.document, {
+    subtree: true, childList: true, attributes: true, characterData: true,
+  });
+  win.addEventListener("error", (e) => errors.push(e.error ?? e.message));
+  process.on("unhandledRejection", (reason) => errors.push(reason));
+
+  await import(entryUrl);
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const started = Date.now();
+  for (;;) {
+    if (errors.length > 0) throw errors[0];
+    if (Date.now() - started > timeout) {
+      throw new Error("did not settle within " + timeout + " ms (" + pending.size + " pending request(s) or prerenderWait() promise(s)). " +
+        "Await the data, skip it with isPrerendering(), or drop the route from prerender.routes.");
+    }
+    if (pending.size > 0) await Promise.race([Promise.all([...pending]), sleep(settle)]);
+    await sleep(settle);
+    if (pending.size === 0 && Date.now() - lastActivity >= settle) break;
+  }
+  if (errors.length > 0) throw errors[0];
+
+  // The template title travels with the page, so the client router can give it
+  // back to a route that sets no title of its own.
+  const titleEl = win.document.head.querySelector("title");
+  if (titleEl && !titleEl.hasAttribute("data-sibu-base-title")) titleEl.setAttribute("data-sibu-base-title", templateTitle);
+
+  parentPort.postMessage({ html: dom.serialize() });
+} catch (err) {
+  fail(err);
 }
-function generateVSCodeSnippets() {
-  return {
-    "SibuJS Component": {
-      prefix: "sibu-component",
-      body: [
-        "import { div } from 'sibujs';",
-        "",
-        "export function ${1:ComponentName}(): HTMLElement {",
-        "	return div({",
-        "		class: '${2:component-class}',",
-        "		nodes: [",
-        "			${3:// nodes here}",
-        "		],",
-        "	});",
-        "}"
-      ],
-      description: "Create a basic SibuJS component"
-    },
-    "SibuJS Component with State": {
-      prefix: "sibu-component-state",
-      body: [
-        "import { div, span } from 'sibujs';",
-        "import { signal } from 'sibujs';",
-        "",
-        "export function ${1:ComponentName}(): HTMLElement {",
-        "	const [${2:value}, ${3:setValue}] = signal(${4:initialValue});",
-        "",
-        "	return div({",
-        "		class: '${5:component-class}',",
-        "		nodes: [",
-        "			() => span({ nodes: String(${2:value}()) }),",
-        "		],",
-        "	});",
-        "}"
-      ],
-      description: "Create a SibuJS component with reactive state"
-    },
-    "SibuJS signal": {
-      prefix: "sibu-state",
-      body: ["const [${1:value}, ${2:setValue}] = signal(${3:initialValue});"],
-      description: "Create a reactive state with signal"
-    },
-    "SibuJS effect": {
-      prefix: "sibu-effect",
-      body: ["const cleanup = effect(() => {", "	${1:// effect logic}", "});"],
-      description: "Create a reactive side effect with effect"
-    },
-    "SibuJS derived": {
-      prefix: "sibu-computed",
-      body: ["const ${1:computed} = derived(() => {", "	return ${2:// derived value};", "});"],
-      description: "Create a derived reactive value with derived"
-    },
-    "SibuJS watch": {
-      prefix: "sibu-watch",
-      body: [
-        "const teardown = watch(",
-        "	() => ${1:watchedValue}(),",
-        "	(newVal, oldVal) => {",
-        "		${2:// handle change}",
-        "	}",
-        ");"
-      ],
-      description: "Watch a reactive value for changes"
-    },
-    "SibuJS each": {
-      prefix: "sibu-each",
-      body: [
-        "each(",
-        "	() => ${1:items}(),",
-        "	(item) => {",
-        "		return ${2:div({ nodes: () => String(item()) })};",
-        "	},",
-        "	{ key: (item) => ${3:item.id} }",
-        ")"
-      ],
-      description: "Create a reactive list with each()"
-    },
-    "SibuJS Context": {
-      prefix: "sibu-context",
-      body: [
-        "const ${1:MyContext} = context(${2:defaultValue});",
-        "",
-        "// In provider component:",
-        "// ${1:MyContext}.provide(value);",
-        "",
-        "// In consumer component:",
-        "// const ${3:value} = ${1:MyContext}.use();"
-      ],
-      description: "Create a context for dependency injection"
-    },
-    "SibuJS store": {
-      prefix: "sibu-store",
-      body: [
-        "const [${1:store}, { setState: ${2:setStore}, reset, subscribe }] = store({",
-        "	${3:key}: ${4:value},",
-        "});"
-      ],
-      description: "Create a reactive global store"
-    },
-    "SibuJS Lazy Component": {
-      prefix: "sibu-lazy",
-      body: ["const ${1:LazyComponent} = lazy(() => import('./${2:ComponentPath}'));"],
-      description: "Create a lazy-loaded component"
-    },
-    "SibuJS Suspense": {
-      prefix: "sibu-suspense",
-      body: [
-        "Suspense({",
-        "	nodes: () => ${1:LazyComponent}(),",
-        "	fallback: () => div({ nodes: '${2:Loading...}' }),",
-        "})"
-      ],
-      description: "Wrap a lazy component with a loading fallback"
-    },
-    "SibuJS onMount": {
-      prefix: "sibu-mount",
-      body: ["onMount(() => {", "	${1:// runs after component enters the DOM}", "});"],
-      description: "Schedule a callback to run after mount"
-    },
-    "SibuJS onUnmount": {
-      prefix: "sibu-unmount",
-      body: ["onUnmount(() => {", "	${1:// cleanup when removed from DOM}", "}, ${2:element});"],
-      description: "Schedule a callback to run on unmount"
-    },
-    "SibuJS Event Handler": {
-      prefix: "sibu-event",
-      body: [
-        "div({",
-        "	on: {",
-        "		${1:click}: (e) => {",
-        "			${2:// handle event}",
-        "		},",
-        "	},",
-        "	nodes: '${3:Click me}',",
-        "})"
-      ],
-      description: "Create an element with event handlers"
-    },
-    "SibuJS Form": {
-      prefix: "sibu-form",
-      body: [
-        "const form = form({",
-        "	${1:fieldName}: {",
-        "		initial: '${2:}',",
-        "		validators: [",
-        "			(value) => !value ? '${3:Required}' : null,",
-        "		],",
-        "	},",
-        "});"
-      ],
-      description: "Create a reactive form with validation"
+`;
+
+// src/build/routeSplitting.ts
+function fileToRoute(relativePath) {
+  const basename = relativePath.split("/").pop() || "";
+  if (basename.startsWith("_")) return null;
+  let route = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+  route = route.replace(/\/index$/, "").replace(/^index$/, "");
+  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
+  route = route.replace(/\[(\w+)\]/g, ":$1");
+  return `/${route}`;
+}
+async function scanRoutes(routesDir, exclude, fs) {
+  const entries = await fs.readdir(routesDir, { withFileTypes: true, recursive: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!/\.(ts|tsx|js|jsx)$/.test(entry.name)) continue;
+    const dir = (entry.parentPath || entry.path || routesDir).replace(/\\/g, "/");
+    const routesDirNorm = routesDir.replace(/\\/g, "/");
+    const relative = `${dir}/${entry.name}`.replace(`${routesDirNorm}/`, "").replace(/\\/g, "/");
+    const excluded = exclude.some((pattern) => {
+      const regex = pattern.replace(/\*/g, ".*");
+      return new RegExp(regex).test(relative);
+    });
+    if (!excluded) {
+      files.push(relative);
     }
-  };
+  }
+  return files.sort();
 }
-function generateLanguageConfig() {
+function buildRouteEntries(files, chunkPrefix) {
+  const entries = [];
+  for (const file of files) {
+    const path = fileToRoute(file);
+    if (path === null) continue;
+    const chunkName = `${chunkPrefix}${file.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/[/\\[\].]/g, "-").replace(/^-+|-+$/g, "").toLowerCase()}`;
+    entries.push({
+      path,
+      importPath: file,
+      chunkName,
+      isDynamic: path.includes(":") || path.includes("*")
+    });
+  }
+  return entries.sort((a, b) => {
+    if (a.path.includes("*") && !b.path.includes("*")) return 1;
+    if (!a.path.includes("*") && b.path.includes("*")) return -1;
+    if (a.isDynamic && !b.isDynamic) return 1;
+    if (!a.isDynamic && b.isDynamic) return -1;
+    return a.path.localeCompare(b.path);
+  });
+}
+function generateRouteModule(entries, routesDir) {
+  const imports = entries.map(
+    (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 "sibujs";
+
+${imports}
+
+export const routes = [
+${routes}
+];
+`;
+}
+var VIRTUAL_ID = "virtual:sibu-routes";
+var RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_ID}`;
+function sibuRouteSplitting(options = {}) {
+  const { routesDir = "src/routes", exclude = [], chunkPrefix = "route-" } = options;
+  let projectRoot = "";
   return {
-    comments: {
-      lineComment: "//",
-      blockComment: ["/*", "*/"]
+    name: "sibu-route-splitting",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ID) {
+        return RESOLVED_VIRTUAL_ID;
+      }
+      return void 0;
     },
-    brackets: [
-      ["{", "}"],
-      ["[", "]"],
-      ["(", ")"],
-      ["<", ">"]
-    ],
-    autoClosingPairs: [
-      { open: "{", close: "}" },
-      { open: "[", close: "]" },
-      { open: "(", close: ")" },
-      { open: "<", close: ">" },
-      { open: "'", close: "'" },
-      { open: '"', close: '"' },
-      { open: "`", close: "`" }
-    ]
+    async load(id) {
+      if (id !== RESOLVED_VIRTUAL_ID) return void 0;
+      const { readdir } = await import("fs/promises");
+      const { resolve } = await import("path");
+      if (!projectRoot) {
+        projectRoot = process.cwd();
+      }
+      const fullRoutesDir = resolve(projectRoot, routesDir);
+      try {
+        const files = await scanRoutes(fullRoutesDir, exclude, {
+          readdir
+        });
+        const entries = buildRouteEntries(files, chunkPrefix);
+        return generateRouteModule(entries, routesDir.startsWith("/") ? routesDir : `./${routesDir}`);
+      } catch {
+        return "export const routes = [];\n";
+      }
+    },
+    handleHotUpdate(ctx) {
+      const normalizedRoutesDir = routesDir.replace(/\\/g, "/");
+      if (ctx.file.replace(/\\/g, "/").includes(normalizedRoutesDir)) {
+        const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
+        if (mod) {
+          ctx.server.moduleGraph.invalidateModule(mod);
+          ctx.server.ws.send({ type: "full-reload" });
+        }
+      }
+    }
   };
 }
-function generateTypeStubs() {
-  return {
-    signal: ["declare function signal<T>(initial: T): [() => T, (next: T | ((prev: T) => T)) => void];"].join("\n"),
-    effect: ["declare function effect(effectFn: () => void): () => void;"].join("\n"),
-    derived: ["declare function derived<T>(getter: () => T): () => T;"].join("\n"),
-    ref: [
-      "interface Ref<T> { current: T; }",
-      "declare function ref<T>(initial: T): Ref<T>;",
-      "declare function ref<T = undefined>(): Ref<T | undefined>;"
-    ].join("\n"),
-    watch: [
-      "declare function watch<T>(getter: () => T, callback: (value: T, prev: T | undefined) => void): () => void;"
-    ].join("\n"),
-    store: [
-      "interface StoreActions<T> {",
-      "  setState: (patch: Partial<T> | ((state: T) => T)) => void;",
-      "  reset: () => void;",
-      "  subscribe: (callback: (state: T) => void) => () => void;",
-      "  subscribeKey: <K extends keyof T>(key: K, callback: (value: T[K], prev: T[K]) => void) => () => void;",
-      "  getSnapshot: () => T;",
-      "}",
-      "declare function store<T extends object>(initialState: T): [{ readonly [K in keyof T]: T[K] }, StoreActions<T>];"
-    ].join("\n"),
-    mount: [
-      "declare function mount(component: (() => HTMLElement) | HTMLElement | Node, container: HTMLElement | null): { node: Node; unmount: () => void };"
-    ].join("\n"),
-    each: [
-      "declare function each<T>(getArray: () => T[], render: (item: T, index: number) => NodeChild, options: { key: (item: T) => string | number }): Comment;"
-    ].join("\n"),
-    onMount: ["declare function onMount(callback: () => void | (() => void), element?: HTMLElement): void;"].join("\n"),
-    onUnmount: ["declare function onUnmount(callback: () => void, element: HTMLElement): void;"].join("\n"),
-    context: [
-      "interface Context<T> {",
-      "  provide(value: T): void;",
-      "  use(): () => T;",
-      "  get(): T;",
-      "  set(value: T): void;",
-      "}",
-      "declare function context<T>(defaultValue: T): Context<T>;"
-    ].join("\n"),
-    lazy: ["declare function lazy(importFn: () => Promise<{ default: () => HTMLElement }>): () => HTMLElement;"].join(
-      "\n"
-    ),
-    Suspense: [
-      "interface SuspenseProps { nodes: () => HTMLElement; fallback: () => HTMLElement; }",
-      "declare function Suspense(props: SuspenseProps): HTMLElement;"
-    ].join("\n"),
-    tagFactory: [
-      "interface TagProps {",
-      "  id?: string;",
-      "  class?: string | (() => string) | Record<string, boolean | (() => boolean)>;",
-      "  style?: Record<string, string | number | (() => string | number)> | string | (() => string);",
-      "  ref?: { current: unknown };",
-      "  nodes?: NodeChildren;",
-      "  on?: Record<string, (ev: Event) => void>;",
-      "  [attr: string]: unknown;",
-      "}",
-      "declare function tagFactory(tag: string, ns?: string): (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;"
-    ].join("\n"),
-    DynamicComponent: ["declare function DynamicComponent(is: () => string | (() => HTMLElement)): HTMLElement;"].join(
-      "\n"
-    ),
-    registerComponent: ["declare function registerComponent(name: string, component: () => HTMLElement): void;"].join(
-      "\n"
-    )
+
+// 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_ELEMENTS2 = /* @__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_ELEMENTS2.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
-function compileHtmlTemplates(code) {
-  const plan = planHtmlTemplates(code);
-  const edits = plan.compiledCount > 0 ? normalizeEdits(plan.edits) : null;
+// src/build/vite.ts
+var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
+var DEFAULT_EXCLUDE = ["node_modules/**", "dist/**", "**/*.test.*", "**/*.spec.*"];
+function matchesPattern(filePath, patterns) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return patterns.some((pattern) => {
+    const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+    return new RegExp(regexStr).test(normalized);
+  });
+}
+function devPrologueEdit(code) {
+  let at = 0;
+  if (code.startsWith("#!")) {
+    const nl = code.indexOf("\n");
+    if (nl === -1) return null;
+    at = nl + 1;
+  }
   return {
-    code: edits ? applyEdits(code, edits, plan.append) : null,
-    usedTags: plan.usedTags,
-    usesSvg: plan.usesSvg,
-    compiledCount: edits ? plan.compiledCount : 0,
-    skippedCount: plan.skippedCount
+    start: at,
+    end: at,
+    text: '/* SibuJS Dev Mode */ if (typeof globalThis !== "undefined") { globalThis.__SIBU_DEV__ = true; } '
   };
 }
-
-// src/build/routeSplitting.ts
-function fileToRoute(relativePath) {
-  const basename = relativePath.split("/").pop() || "";
-  if (basename.startsWith("_")) return null;
-  let route = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
-  route = route.replace(/\/index$/, "").replace(/^index$/, "");
-  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
-  route = route.replace(/\[(\w+)\]/g, ":$1");
-  return `/${route}`;
+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));
 }
-async function scanRoutes(routesDir, exclude, fs) {
-  const entries = await fs.readdir(routesDir, { withFileTypes: true, recursive: true });
-  const files = [];
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    if (!/\.(ts|tsx|js|jsx)$/.test(entry.name)) continue;
-    const dir = (entry.parentPath || entry.path || routesDir).replace(/\\/g, "/");
-    const routesDirNorm = routesDir.replace(/\\/g, "/");
-    const relative = `${dir}/${entry.name}`.replace(`${routesDirNorm}/`, "").replace(/\\/g, "/");
-    const excluded = exclude.some((pattern) => {
-      const regex = pattern.replace(/\*/g, ".*");
-      return new RegExp(regex).test(relative);
-    });
-    if (!excluded) {
-      files.push(relative);
+`;
+  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 {
+    hmr = true,
+    pureAnnotations = true,
+    include = DEFAULT_INCLUDE,
+    exclude = DEFAULT_EXCLUDE,
+    devMode,
+    staticOptimize = false,
+    compileTemplates,
+    prerender: prerenderOptions
+  } = options;
+  let prerenderTarget = null;
+  let isDevMode = resolveDevMode(devMode, void 0);
+  return {
+    name: "sibu-vite-plugin",
+    enforce: "pre",
+    config(_userConfig, env) {
+      isDevMode = resolveDevMode(devMode, env);
+      return {
+        // Optimize dependency pre-bundling for sibujs
+        optimizeDeps: {
+          include: ["sibujs"]
+        },
+        // Ensure sibujs is treated correctly for SSR
+        ssr: {
+          noExternal: ["sibujs"]
+        },
+        // Define global constants for dead code elimination
+        define: {
+          __SIBU_DEV__: JSON.stringify(isDevMode),
+          __SIBU_HMR__: JSON.stringify(hmr)
+        },
+        // Enable source maps in dev
+        build: {
+          sourcemap: isDevMode
+        }
+      };
+    },
+    configResolved(config) {
+      isDevMode = resolveDevMode(devMode, config);
+      if (prerenderOptions && config.command === "build" && !config.build?.ssr && typeof process !== "undefined" && !process.env?.[PRERENDER_CHILD_ENV] && config.root) {
+        const outDir = config.build?.outDir ?? "dist";
+        const absolute = /^([a-zA-Z]:)?[\\/]/.test(outDir);
+        prerenderTarget = {
+          root: config.root,
+          outDir: absolute ? outDir : `${config.root.replace(/[\\/]+$/, "")}/${outDir}`,
+          configFile: config.configFile,
+          mode: config.mode
+        };
+      }
+    },
+    async closeBundle() {
+      if (!prerenderOptions || !prerenderTarget) return;
+      const target = prerenderTarget;
+      prerenderTarget = null;
+      const results = await prerender(prerenderOptions, target);
+      for (const r of results) console.log(`[sibu prerender] ${r.route} \u2192 ${r.file} (${r.ms} ms)`);
+    },
+    transform(code, id) {
+      if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {
+        return null;
+      }
+      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 (pureAnnotations) {
+        edits.push(...pureAnnotationEdits(code));
+      }
+      const shouldCompile = compileTemplates ?? !isDevMode;
+      if (shouldCompile) {
+        const plan = planHtmlTemplates(code);
+        if (plan.compiledCount > 0) {
+          edits.push(...plan.edits);
+          append += plan.append;
+        }
+      }
+      if (staticOptimize) {
+        const optimized = staticOptimizationEdits(code);
+        if (optimized) {
+          edits.push(...optimized.edits);
+          append += optimized.append;
+        }
+      }
+      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: editsSourceMap(code, sorted, append, id)
+      };
+    },
+    handleHotUpdate(ctx) {
+      if (!hmr) return;
+      const { file } = ctx;
+      if (matchesPattern(file, include) && !matchesPattern(file, exclude)) {
+        if (isDevMode) {
+          console.log(`[sibu-vite-plugin] HMR update: ${file}`);
+        }
+        return;
+      }
+    }
+  };
+}
+function createViteConfig(options = {}) {
+  const { entry = "src/main.ts", outDir = "dist", ssr = false, overrides = {} } = options;
+  const baseConfig = {
+    // Use the SibuJS Vite plugin
+    plugins: [sibuVitePlugin()],
+    // Build configuration
+    build: {
+      outDir,
+      target: "es2020",
+      minify: "esbuild",
+      sourcemap: true,
+      // Library mode configuration when building a library
+      lib: ssr ? void 0 : {
+        entry,
+        formats: ["es", "cjs"]
+      },
+      // Rollup-specific options
+      rollupOptions: {
+        input: ssr ? entry : void 0,
+        output: {
+          // Ensure consistent chunk naming
+          chunkFileNames: "chunks/[name]-[hash].js",
+          // Preserve pure annotations
+          generatedCode: {
+            constBindings: true
+          }
+        },
+        // Tree-shaking configuration
+        treeshake: {
+          moduleSideEffects: false,
+          propertyReadSideEffects: false,
+          annotations: true
+        }
+      }
+    },
+    // Resolve configuration
+    resolve: {
+      // Prefer ESM versions of packages
+      mainFields: ["module", "jsnext:main", "jsnext", "main"],
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"]
+    },
+    // SSR configuration
+    ...ssr ? {
+      ssr: {
+        noExternal: ["sibujs"],
+        target: "node"
+      },
+      build: {
+        outDir,
+        target: "node18",
+        ssr: true,
+        rollupOptions: {
+          input: entry,
+          output: {
+            format: "esm"
+          }
+        }
+      }
+    } : {},
+    // Optimize dependency handling
+    optimizeDeps: {
+      include: ["sibujs"],
+      // Force pre-bundling of sibujs for faster dev startup
+      force: false
+    },
+    // Environment variable handling
+    define: {
+      __SIBU_SSR__: JSON.stringify(ssr)
     }
-  }
-  return files.sort();
+  };
+  return deepMerge(baseConfig, overrides);
 }
-function buildRouteEntries(files, chunkPrefix) {
-  const entries = [];
-  for (const file of files) {
-    const path = fileToRoute(file);
-    if (path === null) continue;
-    const chunkName = `${chunkPrefix}${file.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/[/\\[\].]/g, "-").replace(/^-+|-+$/g, "").toLowerCase()}`;
-    entries.push({
-      path,
-      importPath: file,
-      chunkName,
-      isDynamic: path.includes(":") || path.includes("*")
-    });
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
   }
-  return entries.sort((a, b) => {
-    if (a.path.includes("*") && !b.path.includes("*")) return 1;
-    if (!a.path.includes("*") && b.path.includes("*")) return -1;
-    if (a.isDynamic && !b.isDynamic) return 1;
-    if (!a.isDynamic && b.isDynamic) return -1;
-    return a.path.localeCompare(b.path);
-  });
+  return result;
 }
-function generateRouteModule(entries, routesDir) {
-  const imports = entries.map(
-    (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 "sibujs";
-
-${imports}
 
-export const routes = [
-${routes}
-];
-`;
+// src/build/webpack.ts
+function addPureAnnotations(source) {
+  return injectPureAnnotations(source);
 }
-var VIRTUAL_ID = "virtual:sibu-routes";
-var RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_ID}`;
-function sibuRouteSplitting(options = {}) {
-  const { routesDir = "src/routes", exclude = [], chunkPrefix = "route-" } = options;
-  let projectRoot = "";
+function sibuWebpackPlugin(options = {}) {
+  const { devMode } = options;
   return {
-    name: "sibu-route-splitting",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === VIRTUAL_ID) {
-        return RESOLVED_VIRTUAL_ID;
-      }
-      return void 0;
-    },
-    async load(id) {
-      if (id !== RESOLVED_VIRTUAL_ID) return void 0;
-      const { readdir } = await import("fs/promises");
-      const { resolve } = await import("path");
-      if (!projectRoot) {
-        projectRoot = process.cwd();
+    name: "SibuWebpackPlugin",
+    apply(compiler) {
+      if (options.pureAnnotations === true) {
+        console.warn(
+          '[SibuWebpackPlugin] `pureAnnotations` is not applied by the plugin: webpack needs a loader file. Create sibu-pure-loader.cjs containing `module.exports = require("sibujs/build").createPureAnnotationsLoader();` and add a module rule `{ test: /\\.[cm]?[jt]sx?$/, exclude: /node_modules/, use: "./sibu-pure-loader.cjs" }`.'
+        );
       }
-      const fullRoutesDir = resolve(projectRoot, routesDir);
-      try {
-        const files = await scanRoutes(fullRoutesDir, exclude, {
-          readdir
-        });
-        const entries = buildRouteEntries(files, chunkPrefix);
-        return generateRouteModule(entries, routesDir.startsWith("/") ? routesDir : `./${routesDir}`);
-      } catch {
-        return "export const routes = [];\n";
+      compiler.hooks?.compilation?.tap("SibuWebpackPlugin", (compilation) => {
+        const comp = compilation;
+        if (comp.hooks?.optimizeModules) {
+          comp.hooks.optimizeModules.tap("SibuWebpackPlugin", () => {
+          });
+        }
+      });
+      compiler.hooks?.afterResolvers?.tap("SibuWebpackPlugin", () => {
+        if (!compiler.options.resolve) {
+          compiler.options.resolve = {};
+        }
+        if (!compiler.options.resolve.mainFields) {
+          compiler.options.resolve.mainFields = ["module", "main"];
+        }
+        if (!compiler.options.resolve.mainFields.includes("module")) {
+          compiler.options.resolve.mainFields.unshift("module");
+        }
+      });
+      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 = [];
+        }
+        const defines = {
+          __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);
+  };
+}
+function createWebpackConfig(options = {}) {
+  const { entry = "./src/index.ts", outputPath = "dist", mode = "production" } = options;
+  const isDev = mode === "development";
+  return {
+    mode,
+    entry,
+    output: {
+      path: outputPath,
+      filename: isDev ? "[name].js" : "[name].[contenthash:8].js",
+      chunkFilename: isDev ? "[name].chunk.js" : "[name].[contenthash:8].chunk.js",
+      clean: true,
+      // Use ESM output
+      module: true,
+      library: {
+        type: "module"
       }
     },
-    handleHotUpdate(ctx) {
-      const normalizedRoutesDir = routesDir.replace(/\\/g, "/");
-      if (ctx.file.replace(/\\/g, "/").includes(normalizedRoutesDir)) {
-        const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
-        if (mod) {
-          ctx.server.moduleGraph.invalidateModule(mod);
-          ctx.server.ws.send({ type: "full-reload" });
+    // Enable experiments for ESM output
+    experiments: {
+      outputModule: true
+    },
+    resolve: {
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"],
+      mainFields: ["module", "main"],
+      alias: {}
+    },
+    module: {
+      rules: [
+        // TypeScript/JavaScript handling
+        {
+          test: /\.[jt]sx?$/,
+          exclude: /node_modules/,
+          use: [
+            {
+              // Users should configure their preferred TS loader
+              // (ts-loader, babel-loader, esbuild-loader, swc-loader)
+              loader: "ts-loader",
+              options: {
+                transpileOnly: true,
+                compilerOptions: {
+                  module: "esnext",
+                  moduleResolution: "node",
+                  target: "es2020"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    plugins: [
+      // SibuJS plugin for optimizations
+      sibuWebpackPlugin({ devMode: isDev })
+    ],
+    optimization: {
+      minimize: !isDev,
+      // Enable tree-shaking
+      usedExports: true,
+      sideEffects: true,
+      // Split chunks for better caching
+      splitChunks: isDev ? false : {
+        chunks: "all",
+        cacheGroups: {
+          // Separate sibujs framework code into its own chunk (the package
+          // directory is `sibujs`; matching `sibu` never selected anything)
+          sibu: {
+            test: /[\\/]node_modules[\\/]sibujs[\\/]/,
+            name: "sibu",
+            chunks: "all",
+            priority: 20
+          },
+          // Separate other vendor code
+          vendor: {
+            test: /[\\/]node_modules[\\/]/,
+            name: "vendor",
+            chunks: "all",
+            priority: 10
+          }
         }
       }
+    },
+    // Source maps
+    devtool: isDev ? "eval-cheap-module-source-map" : "source-map",
+    // Dev server configuration
+    devServer: isDev ? {
+      hot: true,
+      open: true,
+      port: 3e3,
+      historyApiFallback: true
+    } : void 0,
+    // Performance hints
+    performance: {
+      hints: isDev ? false : "warning",
+      maxEntrypointSize: 25e4,
+      maxAssetSize: 25e4
+    },
+    // Cache for faster rebuilds
+    cache: {
+      type: "filesystem",
+      buildDependencies: {
+        config: []
+      }
     }
   };
 }
 export {
+  PRERENDER_CHILD_ENV,
   analyzeBundle,
   analyzeStaticTemplates,
   buildRouteEntries,
@@ -3248,8 +3599,10 @@ export {
   createPureAnnotationsLoader,
   createViteConfig,
   createWebpackConfig,
+  esmEntryOf,
   estimateImportSize,
   fileToRoute,
+  findEntryInHtml,
   generateEslintConfig,
   generateImportMap,
   generateLanguageConfig,
@@ -3260,7 +3613,10 @@ export {
   lintRules,
   lintSource,
   moduleSizes,
+  outputFileFor,
+  prerender,
   registerGlobal,
+  resolveInsideOutDir,
   sibuRouteSplitting,
   sibuVitePlugin,
   sibuWebpackPlugin,