@vertz/ui-server 0.2.25 → 0.2.28

package/dist/index.js

@@ -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) {
@@ -428,14 +484,16 @@ async function renderToHTML(appOrOptions, maybeOptions) {
   });
 }
 // src/ssr-access-evaluator.ts
-function toPrefetchSession(ssrAuth) {
+function toPrefetchSession(ssrAuth, accessSet) {
   if (!ssrAuth || ssrAuth.status !== "authenticated" || !ssrAuth.user) {
     return { status: "unauthenticated" };
   }
   const roles = ssrAuth.user.role ? [ssrAuth.user.role] : undefined;
+  const entitlements = accessSet != null ? Object.fromEntries(Object.entries(accessSet.entitlements).map(([name, check]) => [name, check.allowed])) : undefined;
   return {
     status: "authenticated",
     roles,
+    entitlements,
     tenantId: ssrAuth.user.tenantId
   };
 }
@@ -467,144 +525,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 +695,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 +830,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 +1123,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 +1532,7 @@ export {
   ssrStorage,
   ssrRenderToString,
   ssrRenderSinglePass,
+  ssrRenderAot,
   ssrDiscoverQueries,
   setGlobalSSRTimeout,
   serializeToHtml,
@@ -1054,6 +1549,7 @@ export {
   rawHtml,
   matchUrlToPatterns,
   isInSSR,
+  isAotDebugEnabled,
   inlineCriticalCss,
   getStreamingRuntimeScript,
   getSSRUrl,
@@ -1061,6 +1557,7 @@ export {
   getGlobalSSRTimeout,
   getAccessSetForSSR,
   generateSSRHtml,
+  generateAotBuildManifest,
   extractFontMetrics,
   evaluateAccessRule,
   encodeChunk,
@@ -1072,8 +1569,15 @@ export {
   createSSRDataChunk,
   createSSRAdapter,
   createPrefetchManifestManager,
+  createHoles,
+  createAotManifestManager,
   createAccessSetScript,
   collectStreamChunks,
   clearGlobalSSRTimeout,
-  HeadCollector
+  __ssr_style_object,
+  __ssr_spread,
+  __esc_attr,
+  __esc,
+  HeadCollector,
+  AotDiagnostics
 };