npm - @vertz/ui-server - Versions diffs - 0.2.25 → 0.2.26 - Mend

@vertz/ui-server 0.2.25 → 0.2.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/bun-dev-server.js +244 -2
package/dist/bun-plugin/index.d.ts +1 -1
package/dist/index.d.ts +333 -85
package/dist/index.js +655 -153
package/package.json +5 -5

package/dist/index.js CHANGED Viewed

@@ -35,6 +35,62 @@ import {
   toVNode
 } from "./shared/chunk-gcwqkynf.js";
+// src/aot-manifest-build.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { compileForSSRAot } from "@vertz/ui-compiler";
+function generateAotBuildManifest(srcDir) {
+  const components = {};
+  const classificationLog = [];
+  const tsxFiles = collectTsxFiles(srcDir);
+  for (const filePath of tsxFiles) {
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      const result = compileForSSRAot(source, { filename: filePath });
+      for (const comp of result.components) {
+        components[comp.name] = {
+          tier: comp.tier,
+          holes: comp.holes
+        };
+      }
+    } catch (e) {
+      classificationLog.push(`⚠ ${filePath}: ${e instanceof Error ? e.message : "compilation failed"}`);
+    }
+  }
+  let aotCount = 0;
+  let runtimeCount = 0;
+  for (const [name, entry] of Object.entries(components)) {
+    let line = `${name}: ${entry.tier}`;
+    if (entry.holes.length > 0) {
+      const holeLabel = entry.holes.length === 1 ? "hole" : "holes";
+      line += `, ${entry.holes.length} ${holeLabel} (${entry.holes.join(", ")})`;
+    }
+    classificationLog.push(line);
+    if (entry.tier === "runtime-fallback") {
+      runtimeCount++;
+    } else {
+      aotCount++;
+    }
+  }
+  const total = aotCount + runtimeCount;
+  if (total > 0) {
+    const pct = Math.round(aotCount / total * 100);
+    classificationLog.push(`Coverage: ${aotCount}/${total} components (${pct}%)`);
+  }
+  return { components, classificationLog };
+}
+function collectTsxFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectTsxFiles(fullPath));
+    } else if (entry.name.endsWith(".tsx")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
 // src/asset-pipeline.ts
 function renderAssetTags(assets) {
   if (assets.length === 0)
@@ -63,7 +119,7 @@ function inlineCriticalCss(css) {
 // src/font-metrics.ts
 import { access as fsAccess } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { fromBuffer } from "@capsizecss/unpack";
 var SYSTEM_FONT_METRICS = {
   Arial: {
@@ -132,12 +188,12 @@ function getPrimarySrcPath(descriptor) {
 }
 async function resolveFilePath(urlPath, rootDir) {
   const cleaned = urlPath.startsWith("/") ? urlPath.slice(1) : urlPath;
-  const direct = join(rootDir, cleaned);
+  const direct = join2(rootDir, cleaned);
   try {
     await fsAccess(direct);
     return direct;
   } catch {
-    return join(rootDir, "public", cleaned);
+    return join2(rootDir, "public", cleaned);
   }
 }
 async function extractFontMetrics(fonts, rootDir) {
@@ -467,144 +523,168 @@ function evaluateAccessRule(rule, session) {
       return false;
   }
 }
-// src/ssr-html.ts
-function generateSSRHtml(options) {
-  const {
-    appHtml,
-    css,
-    ssrData,
-    clientEntry,
-    title = "Vertz App",
-    headTags: rawHeadTags = "",
-    modulepreload
-  } = options;
-  const modulepreloadTags = modulepreload?.length ? modulepreload.map((p) => `<link rel="modulepreload" href="${escapeAttr(p)}">`).join(`
-`) : "";
-  const headTags = [rawHeadTags, modulepreloadTags].filter(Boolean).join(`
-`);
-  const ssrDataScript = ssrData.length > 0 ? `<script>window.__VERTZ_SSR_DATA__ = ${JSON.stringify(ssrData)};</script>` : "";
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${escapeHtml(title)}</title>
-    ${headTags}
-    ${css}
-  </head>
-  <body>
-    <div id="app">${appHtml}</div>
-    ${ssrDataScript}
-    <script type="module" src="${escapeAttr(clientEntry)}"></script>
-  </body>
-</html>`;
-}
-// src/ssr-prefetch-dev.ts
-import {
-  analyzeComponentQueries,
-  generatePrefetchManifest
-} from "@vertz/ui-compiler";
-function createPrefetchManifestManager(options) {
-  const { routerPath, readFile: readFile2, resolveImport } = options;
-  let currentManifest = null;
-  let currentSSRManifest;
-  let rebuildCount = 0;
-  let lastRebuildMs = null;
-  let lastRebuildAt = null;
-  let fileToRouteIndices = new Map;
-  function buildFileIndex(routes) {
-    const index = new Map;
-    for (let i = 0;i < routes.length; i++) {
-      const file = routes[i]?.file;
-      if (file) {
-        const existing = index.get(file) ?? [];
-        existing.push(i);
-        index.set(file, existing);
+// src/ssr-aot-diagnostics.ts
+var MAX_DIVERGENCES = 20;
+class AotDiagnostics {
+  _components = new Map;
+  _divergences = [];
+  recordCompilation(components) {
+    for (const comp of components) {
+      this._components.set(comp.name, {
+        tier: comp.tier,
+        holes: comp.holes
+      });
+    }
+  }
+  recordDivergence(component, aotHtml, domHtml) {
+    this._divergences.push({
+      component,
+      aotHtml,
+      domHtml,
+      timestamp: new Date().toISOString()
+    });
+    if (this._divergences.length > MAX_DIVERGENCES) {
+      this._divergences = this._divergences.slice(this._divergences.length - MAX_DIVERGENCES);
+    }
+  }
+  clear() {
+    this._components.clear();
+    this._divergences = [];
+  }
+  clearComponents() {
+    this._components.clear();
+  }
+  getClassificationLog() {
+    const lines = [];
+    for (const [name, comp] of this._components) {
+      let line = `${name}: ${comp.tier}`;
+      if (comp.holes.length > 0) {
+        line += `, ${comp.holes.length} hole${comp.holes.length > 1 ? "s" : ""} (${comp.holes.join(", ")})`;
       }
+      lines.push(line);
     }
-    return index;
+    const snapshot = this.getSnapshot();
+    const { total, aot, percentage } = snapshot.coverage;
+    if (total > 0) {
+      lines.push(`Coverage: ${aot}/${total} components (${percentage}%)`);
+    }
+    return lines;
   }
-  function toSSRManifest(manifest) {
-    const routeEntries = {};
-    for (const route of manifest.routes) {
-      const existing = routeEntries[route.pattern];
-      if (existing) {
-        existing.queries.push(...route.queries);
+  getSnapshot() {
+    let aot = 0;
+    let runtime = 0;
+    for (const comp of this._components.values()) {
+      if (comp.tier === "runtime-fallback") {
+        runtime++;
       } else {
-        routeEntries[route.pattern] = { queries: [...route.queries] };
+        aot++;
       }
     }
+    const total = aot + runtime;
     return {
-      routePatterns: [...new Set(manifest.routes.map((r) => r.pattern))],
-      routeEntries
+      components: Object.fromEntries(this._components),
+      coverage: {
+        total,
+        aot,
+        runtime,
+        percentage: total === 0 ? 0 : Math.round(aot / total * 100)
+      },
+      divergences: [...this._divergences]
     };
   }
-  function fullBuild(routerSourceOverride) {
+}
+// src/ssr-aot-manifest-dev.ts
+import { compileForSSRAot as compileForSSRAot2 } from "@vertz/ui-compiler";
+function createAotManifestManager(options) {
+  const { readFile: readFile2, listFiles } = options;
+  let currentManifest = null;
+  const diagnostics = new AotDiagnostics;
+  let rebuildCount = 0;
+  let lastRebuildMs = null;
+  let lastRebuildAt = null;
+  function compileFile(filePath, source) {
+    try {
+      const result = compileForSSRAot2(source, { filename: filePath });
+      return result.components.map((comp) => ({
+        name: comp.name,
+        entry: {
+          tier: comp.tier,
+          holes: comp.holes,
+          file: filePath
+        }
+      }));
+    } catch {
+      return [];
+    }
+  }
+  function updateDiagnostics(manifest, isFullBuild) {
+    if (isFullBuild) {
+      diagnostics.clear();
+    } else {
+      diagnostics.clearComponents();
+    }
+    const entries = Object.entries(manifest.components).map(([name, entry]) => ({
+      name,
+      tier: entry.tier,
+      holes: entry.holes
+    }));
+    diagnostics.recordCompilation(entries);
+  }
+  function fullBuild() {
     const start = performance.now();
-    const routerSource = routerSourceOverride ?? readFile2(routerPath);
-    if (!routerSource) {
-      return;
+    const files = listFiles();
+    const components = {};
+    for (const filePath of files) {
+      if (!filePath.endsWith(".tsx"))
+        continue;
+      const source = readFile2(filePath);
+      if (!source)
+        continue;
+      const entries = compileFile(filePath, source);
+      for (const { name, entry } of entries) {
+        components[name] = entry;
+      }
     }
-    try {
-      const manifest = generatePrefetchManifest({
-        routerSource,
-        routerPath,
-        readFile: readFile2,
-        resolveImport
-      });
-      currentManifest = manifest;
-      currentSSRManifest = toSSRManifest(manifest);
-      fileToRouteIndices = buildFileIndex(manifest.routes);
-      rebuildCount++;
-      lastRebuildMs = Math.round(performance.now() - start);
-      lastRebuildAt = new Date().toISOString();
-    } catch {}
+    currentManifest = { components };
+    updateDiagnostics(currentManifest, true);
+    rebuildCount++;
+    lastRebuildMs = Math.round(performance.now() - start);
+    lastRebuildAt = new Date().toISOString();
   }
   function incrementalUpdate(filePath, sourceText) {
     if (!currentManifest)
       return;
-    const indices = fileToRouteIndices.get(filePath);
-    if (!indices || indices.length === 0)
-      return;
     const start = performance.now();
-    try {
-      const analysis = analyzeComponentQueries(sourceText, filePath);
-      const newRoutes = [...currentManifest.routes];
-      for (const idx of indices) {
-        const existing = newRoutes[idx];
-        if (existing) {
-          newRoutes[idx] = {
-            ...existing,
-            queries: analysis.queries,
-            params: analysis.params
-          };
-        }
+    const newComponents = { ...currentManifest.components };
+    for (const [name, entry] of Object.entries(newComponents)) {
+      if (entry.file === filePath) {
+        delete newComponents[name];
       }
-      const newManifest = {
-        ...currentManifest,
-        routes: newRoutes,
-        generatedAt: new Date().toISOString()
-      };
-      currentManifest = newManifest;
-      currentSSRManifest = toSSRManifest(newManifest);
-      rebuildCount++;
-      lastRebuildMs = Math.round(performance.now() - start);
-      lastRebuildAt = new Date().toISOString();
-    } catch {}
+    }
+    if (sourceText.trim()) {
+      const entries = compileFile(filePath, sourceText);
+      for (const { name, entry } of entries) {
+        newComponents[name] = entry;
+      }
+    }
+    currentManifest = { components: newComponents };
+    updateDiagnostics(currentManifest, false);
+    rebuildCount++;
+    lastRebuildMs = Math.round(performance.now() - start);
+    lastRebuildAt = new Date().toISOString();
   }
   return {
     build() {
       fullBuild();
     },
     onFileChange(filePath, sourceText) {
-      if (filePath === routerPath) {
-        fullBuild(sourceText);
-      } else {
-        incrementalUpdate(filePath, sourceText);
-      }
+      if (!filePath.endsWith(".tsx"))
+        return;
+      incrementalUpdate(filePath, sourceText);
     },
-    getSSRManifest() {
-      return currentSSRManifest;
+    getManifest() {
+      return currentManifest;
     },
     getSnapshot() {
       return {
@@ -613,9 +693,53 @@ function createPrefetchManifestManager(options) {
         lastRebuildMs,
         lastRebuildAt
       };
+    },
+    getDiagnostics() {
+      return diagnostics;
     }
   };
 }
+// src/ssr-aot-pipeline.ts
+import { compileTheme as compileTheme3 } from "@vertz/ui";
+// src/ssr-route-matcher.ts
+function matchUrlToPatterns(url, patterns) {
+  const path = (url.split("?")[0] ?? "").split("#")[0] ?? "";
+  const matches = [];
+  for (const pattern of patterns) {
+    const result = matchPattern(path, pattern);
+    if (result) {
+      matches.push(result);
+    }
+  }
+  matches.sort((a, b) => {
+    const aSegments = a.pattern.split("/").length;
+    const bSegments = b.pattern.split("/").length;
+    return aSegments - bSegments;
+  });
+  return matches;
+}
+function matchPattern(path, pattern) {
+  const pathSegments = path.split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length)
+    return;
+  const params = {};
+  for (let i = 0;i < patternSegments.length; i++) {
+    const seg = patternSegments[i];
+    const val = pathSegments[i];
+    if (seg.startsWith(":")) {
+      params[seg.slice(1)] = val;
+    } else if (seg !== val) {
+      return;
+    }
+  }
+  return { pattern, params };
+}
+// src/ssr-single-pass.ts
+import { compileTheme as compileTheme2 } from "@vertz/ui";
 // src/ssr-manifest-prefetch.ts
 function reconstructDescriptors(queries, routeParams, apiClient) {
   if (!apiClient)
@@ -704,42 +828,8 @@ function resolveQueryBindings(bindings, routeParams) {
     resolved.limit = bindings.limit;
   return resolved;
 }
-// src/ssr-route-matcher.ts
-function matchUrlToPatterns(url, patterns) {
-  const path = (url.split("?")[0] ?? "").split("#")[0] ?? "";
-  const matches = [];
-  for (const pattern of patterns) {
-    const result = matchPattern(path, pattern);
-    if (result) {
-      matches.push(result);
-    }
-  }
-  matches.sort((a, b) => {
-    const aSegments = a.pattern.split("/").length;
-    const bSegments = b.pattern.split("/").length;
-    return aSegments - bSegments;
-  });
-  return matches;
-}
-function matchPattern(path, pattern) {
-  const pathSegments = path.split("/").filter(Boolean);
-  const patternSegments = pattern.split("/").filter(Boolean);
-  if (patternSegments.length > pathSegments.length)
-    return;
-  const params = {};
-  for (let i = 0;i < patternSegments.length; i++) {
-    const seg = patternSegments[i];
-    const val = pathSegments[i];
-    if (seg.startsWith(":")) {
-      params[seg.slice(1)] = val;
-    } else if (seg !== val) {
-      return;
-    }
-  }
-  return { pattern, params };
-}
 // src/ssr-single-pass.ts
-import { compileTheme as compileTheme2 } from "@vertz/ui";
 async function ssrRenderSinglePass(module, url, options) {
   if (options?.prefetch === false) {
     return ssrRenderToString(module, url, options);
@@ -1031,6 +1121,408 @@ function collectCSS(themeCss, module) {
   return [themeTag, globalTag, componentTag].filter(Boolean).join(`
 `);
 }
+// src/ssr-aot-pipeline.ts
+function createHoles(holeNames, module, url, queryCache, ssrAuth) {
+  if (holeNames.length === 0)
+    return {};
+  const holes = {};
+  for (const name of holeNames) {
+    holes[name] = () => {
+      const holeCtx = createRequestContext(url);
+      for (const [key, data] of queryCache) {
+        holeCtx.queryCache.set(key, data);
+      }
+      if (ssrAuth) {
+        holeCtx.ssrAuth = ssrAuth;
+      }
+      holeCtx.resolvedComponents = new Map;
+      return ssrStorage.run(holeCtx, () => {
+        ensureDomShim2();
+        const factory = resolveHoleComponent(module, name);
+        if (!factory) {
+          return `<!-- AOT hole: ${name} not found -->`;
+        }
+        const node = factory();
+        const vnode = toVNode(node);
+        return serializeToHtml(vnode);
+      });
+    };
+  }
+  return holes;
+}
+function resolveHoleComponent(module, name) {
+  const moduleRecord = module;
+  const exported = moduleRecord[name];
+  if (typeof exported === "function") {
+    return exported;
+  }
+  return;
+}
+async function ssrRenderAot(module, url, options) {
+  const { aotManifest, manifest } = options;
+  const ssrTimeout = options.ssrTimeout ?? 300;
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const fallbackOptions = {
+    ssrTimeout,
+    fallbackMetrics: options.fallbackMetrics,
+    ssrAuth: options.ssrAuth,
+    manifest,
+    prefetchSession: options.prefetchSession
+  };
+  const aotPatterns = Object.keys(aotManifest.routes);
+  const matches = matchUrlToPatterns(normalizedUrl, aotPatterns);
+  if (matches.length === 0) {
+    return ssrRenderSinglePass(module, normalizedUrl, fallbackOptions);
+  }
+  const match = matches[matches.length - 1];
+  if (!match) {
+    return ssrRenderSinglePass(module, normalizedUrl, fallbackOptions);
+  }
+  const aotEntry = aotManifest.routes[match.pattern];
+  if (!aotEntry) {
+    return ssrRenderSinglePass(module, normalizedUrl, fallbackOptions);
+  }
+  const queryCache = new Map;
+  try {
+    setGlobalSSRTimeout(ssrTimeout);
+    const holes = createHoles(aotEntry.holes, module, normalizedUrl, queryCache, options.ssrAuth);
+    const ctx = {
+      holes,
+      getData: (key) => queryCache.get(key),
+      session: options.prefetchSession,
+      params: match.params
+    };
+    const data = {};
+    for (const [key, value] of queryCache) {
+      data[key] = value;
+    }
+    const html = aotEntry.render(data, ctx);
+    if (options.diagnostics && isAotDebugEnabled()) {
+      try {
+        const domResult = await ssrRenderSinglePass(module, normalizedUrl, fallbackOptions);
+        if (domResult.html !== html) {
+          options.diagnostics.recordDivergence(match.pattern, html, domResult.html);
+        }
+      } catch {}
+    }
+    const css = collectCSSFromModule(module, options.fallbackMetrics);
+    const ssrData = [];
+    for (const [key, data2] of queryCache) {
+      ssrData.push({ key, data: JSON.parse(JSON.stringify(data2)) });
+    }
+    return {
+      html,
+      css: css.cssString,
+      ssrData,
+      headTags: css.preloadTags
+    };
+  } finally {
+    clearGlobalSSRTimeout();
+  }
+}
+function isAotDebugEnabled() {
+  const env = process.env.VERTZ_DEBUG;
+  if (!env)
+    return false;
+  return env === "1" || env.split(",").includes("aot");
+}
+var domShimInstalled2 = false;
+function ensureDomShim2() {
+  if (domShimInstalled2 && typeof document !== "undefined")
+    return;
+  domShimInstalled2 = true;
+  installDomShim();
+}
+function collectCSSFromModule(module, fallbackMetrics) {
+  let themeCss = "";
+  let preloadTags = "";
+  if (module.theme) {
+    try {
+      const compiled = compileTheme3(module.theme, { fallbackMetrics });
+      themeCss = compiled.css;
+      preloadTags = compiled.preloadTags;
+    } catch (e) {
+      console.error("[vertz] Failed to compile theme export. Ensure your theme is created with defineTheme().", e);
+    }
+  }
+  const alreadyIncluded = new Set;
+  if (themeCss)
+    alreadyIncluded.add(themeCss);
+  if (module.styles) {
+    for (const s of module.styles)
+      alreadyIncluded.add(s);
+  }
+  const componentCss = module.getInjectedCSS ? module.getInjectedCSS().filter((s) => !alreadyIncluded.has(s)) : [];
+  const themeTag = themeCss ? `<style data-vertz-css>${themeCss}</style>` : "";
+  const globalTag = module.styles && module.styles.length > 0 ? `<style data-vertz-css>${module.styles.join(`
+`)}</style>` : "";
+  const componentTag = componentCss.length > 0 ? `<style data-vertz-css>${componentCss.join(`
+`)}</style>` : "";
+  const cssString = [themeTag, globalTag, componentTag].filter(Boolean).join(`
+`);
+  return { cssString, preloadTags };
+}
+// src/ssr-aot-runtime.ts
+var UNITLESS_PROPERTIES = new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "fontWeight",
+  "gridArea",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom"
+]);
+function __esc(value) {
+  if (value == null || value === false)
+    return "";
+  if (value === true)
+    return "true";
+  if (typeof value === "number")
+    return String(value);
+  if (Array.isArray(value))
+    return value.map(__esc).join("");
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function __esc_attr(value) {
+  const str = typeof value === "string" ? value : String(value);
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function __ssr_spread(props) {
+  const parts = [];
+  for (const key in props) {
+    const value = props[key];
+    if (value == null || value === false)
+      continue;
+    const third = key.charAt(2);
+    if (key.length > 2 && key.charAt(0) === "o" && key.charAt(1) === "n" && third >= "A" && third <= "Z") {
+      continue;
+    }
+    if (typeof value === "function")
+      continue;
+    if (key === "key" || key === "ref" || key === "children")
+      continue;
+    const attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key;
+    if (key === "style" && typeof value === "object") {
+      const css = __ssr_style_object(value);
+      if (css) {
+        parts.push(` style="${__esc_attr(css)}"`);
+      }
+      continue;
+    }
+    if (value === true) {
+      parts.push(` ${attrName}`);
+      continue;
+    }
+    parts.push(` ${attrName}="${__esc_attr(value)}"`);
+  }
+  return parts.join("");
+}
+function camelToKebab(prop) {
+  if (prop.startsWith("--"))
+    return prop;
+  if (prop.startsWith("ms")) {
+    return `-${prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+  }
+  const first = prop.charAt(0);
+  if (first >= "A" && first <= "Z") {
+    return `-${first.toLowerCase()}${prop.slice(1).replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+  }
+  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function __ssr_style_object(style) {
+  const parts = [];
+  for (const prop in style) {
+    const value = style[prop];
+    if (value == null || value === "")
+      continue;
+    const cssProp = camelToKebab(prop);
+    if (typeof value === "number" && value !== 0 && !UNITLESS_PROPERTIES.has(prop)) {
+      parts.push(`${cssProp}: ${value}px`);
+    } else {
+      parts.push(`${cssProp}: ${value}`);
+    }
+  }
+  return parts.join("; ");
+}
+// src/ssr-html.ts
+function generateSSRHtml(options) {
+  const {
+    appHtml,
+    css,
+    ssrData,
+    clientEntry,
+    title = "Vertz App",
+    headTags: rawHeadTags = "",
+    modulepreload
+  } = options;
+  const modulepreloadTags = modulepreload?.length ? modulepreload.map((p) => `<link rel="modulepreload" href="${escapeAttr(p)}">`).join(`
+`) : "";
+  const headTags = [rawHeadTags, modulepreloadTags].filter(Boolean).join(`
+`);
+  const ssrDataScript = ssrData.length > 0 ? `<script>window.__VERTZ_SSR_DATA__ = ${JSON.stringify(ssrData)};</script>` : "";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${escapeHtml(title)}</title>
+    ${headTags}
+    ${css}
+  </head>
+  <body>
+    <div id="app">${appHtml}</div>
+    ${ssrDataScript}
+    <script type="module" src="${escapeAttr(clientEntry)}"></script>
+  </body>
+</html>`;
+}
+// src/ssr-prefetch-dev.ts
+import {
+  analyzeComponentQueries,
+  generatePrefetchManifest
+} from "@vertz/ui-compiler";
+function createPrefetchManifestManager(options) {
+  const { routerPath, readFile: readFile2, resolveImport } = options;
+  let currentManifest = null;
+  let currentSSRManifest;
+  let rebuildCount = 0;
+  let lastRebuildMs = null;
+  let lastRebuildAt = null;
+  let fileToRouteIndices = new Map;
+  function buildFileIndex(routes) {
+    const index = new Map;
+    for (let i = 0;i < routes.length; i++) {
+      const file = routes[i]?.file;
+      if (file) {
+        const existing = index.get(file) ?? [];
+        existing.push(i);
+        index.set(file, existing);
+      }
+    }
+    return index;
+  }
+  function toSSRManifest(manifest) {
+    const routeEntries = {};
+    for (const route of manifest.routes) {
+      const existing = routeEntries[route.pattern];
+      if (existing) {
+        existing.queries.push(...route.queries);
+      } else {
+        routeEntries[route.pattern] = { queries: [...route.queries] };
+      }
+    }
+    return {
+      routePatterns: [...new Set(manifest.routes.map((r) => r.pattern))],
+      routeEntries
+    };
+  }
+  function fullBuild(routerSourceOverride) {
+    const start = performance.now();
+    const routerSource = routerSourceOverride ?? readFile2(routerPath);
+    if (!routerSource) {
+      return;
+    }
+    try {
+      const manifest = generatePrefetchManifest({
+        routerSource,
+        routerPath,
+        readFile: readFile2,
+        resolveImport
+      });
+      currentManifest = manifest;
+      currentSSRManifest = toSSRManifest(manifest);
+      fileToRouteIndices = buildFileIndex(manifest.routes);
+      rebuildCount++;
+      lastRebuildMs = Math.round(performance.now() - start);
+      lastRebuildAt = new Date().toISOString();
+    } catch {}
+  }
+  function incrementalUpdate(filePath, sourceText) {
+    if (!currentManifest)
+      return;
+    const indices = fileToRouteIndices.get(filePath);
+    if (!indices || indices.length === 0)
+      return;
+    const start = performance.now();
+    try {
+      const analysis = analyzeComponentQueries(sourceText, filePath);
+      const newRoutes = [...currentManifest.routes];
+      for (const idx of indices) {
+        const existing = newRoutes[idx];
+        if (existing) {
+          newRoutes[idx] = {
+            ...existing,
+            queries: analysis.queries,
+            params: analysis.params
+          };
+        }
+      }
+      const newManifest = {
+        ...currentManifest,
+        routes: newRoutes,
+        generatedAt: new Date().toISOString()
+      };
+      currentManifest = newManifest;
+      currentSSRManifest = toSSRManifest(newManifest);
+      rebuildCount++;
+      lastRebuildMs = Math.round(performance.now() - start);
+      lastRebuildAt = new Date().toISOString();
+    } catch {}
+  }
+  return {
+    build() {
+      fullBuild();
+    },
+    onFileChange(filePath, sourceText) {
+      if (filePath === routerPath) {
+        fullBuild(sourceText);
+      } else {
+        incrementalUpdate(filePath, sourceText);
+      }
+    },
+    getSSRManifest() {
+      return currentSSRManifest;
+    },
+    getSnapshot() {
+      return {
+        manifest: currentManifest,
+        rebuildCount,
+        lastRebuildMs,
+        lastRebuildAt
+      };
+    }
+  };
+}
 export {
   wrapWithHydrationMarkers,
   toPrefetchSession,
@@ -1038,6 +1530,7 @@ export {
   ssrStorage,
   ssrRenderToString,
   ssrRenderSinglePass,
+  ssrRenderAot,
   ssrDiscoverQueries,
   setGlobalSSRTimeout,
   serializeToHtml,
@@ -1054,6 +1547,7 @@ export {
   rawHtml,
   matchUrlToPatterns,
   isInSSR,
+  isAotDebugEnabled,
   inlineCriticalCss,
   getStreamingRuntimeScript,
   getSSRUrl,
@@ -1061,6 +1555,7 @@ export {
   getGlobalSSRTimeout,
   getAccessSetForSSR,
   generateSSRHtml,
+  generateAotBuildManifest,
   extractFontMetrics,
   evaluateAccessRule,
   encodeChunk,
@@ -1072,8 +1567,15 @@ export {
   createSSRDataChunk,
   createSSRAdapter,
   createPrefetchManifestManager,
+  createHoles,
+  createAotManifestManager,
   createAccessSetScript,
   collectStreamChunks,
   clearGlobalSSRTimeout,
-  HeadCollector
+  __ssr_style_object,
+  __ssr_spread,
+  __esc_attr,
+  __esc,
+  HeadCollector,
+  AotDiagnostics
 };