@vertz/ui-server 0.2.24 → 0.2.26

package/dist/index.js

@@ -19,20 +19,78 @@ import {
   ssrDiscoverQueries,
   ssrRenderToString,
   streamToString
-} from "./shared/chunk-g0zqrb60.js";
+} from "./shared/chunk-yr65qdge.js";
 import {
   clearGlobalSSRTimeout,
   createSSRAdapter,
   getGlobalSSRTimeout,
   getSSRQueries,
   getSSRUrl,
+  installDomShim,
   isInSSR,
   rawHtml,
   registerSSRQuery,
   setGlobalSSRTimeout,
-  ssrStorage
-} from "./shared/chunk-zs75v8qj.js";
+  ssrStorage,
+  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)
@@ -61,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: {
@@ -130,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) {
@@ -425,6 +483,897 @@ async function renderToHTML(appOrOptions, maybeOptions) {
     }
   });
 }
+// src/ssr-access-evaluator.ts
+function toPrefetchSession(ssrAuth) {
+  if (!ssrAuth || ssrAuth.status !== "authenticated" || !ssrAuth.user) {
+    return { status: "unauthenticated" };
+  }
+  const roles = ssrAuth.user.role ? [ssrAuth.user.role] : undefined;
+  return {
+    status: "authenticated",
+    roles,
+    tenantId: ssrAuth.user.tenantId
+  };
+}
+function evaluateAccessRule(rule, session) {
+  switch (rule.type) {
+    case "public":
+      return true;
+    case "authenticated":
+      return session.status === "authenticated";
+    case "role":
+      if (session.status !== "authenticated")
+        return false;
+      return session.roles?.some((r) => rule.roles.includes(r)) === true;
+    case "entitlement":
+      if (session.status !== "authenticated")
+        return false;
+      return session.entitlements?.[rule.value] === true;
+    case "where":
+      return true;
+    case "fva":
+      return session.status === "authenticated";
+    case "deny":
+      return false;
+    case "all":
+      return rule.rules.every((r) => evaluateAccessRule(r, session));
+    case "any":
+      return rule.rules.some((r) => evaluateAccessRule(r, session));
+    default:
+      return false;
+  }
+}
+// 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);
+    }
+    const snapshot = this.getSnapshot();
+    const { total, aot, percentage } = snapshot.coverage;
+    if (total > 0) {
+      lines.push(`Coverage: ${aot}/${total} components (${percentage}%)`);
+    }
+    return lines;
+  }
+  getSnapshot() {
+    let aot = 0;
+    let runtime = 0;
+    for (const comp of this._components.values()) {
+      if (comp.tier === "runtime-fallback") {
+        runtime++;
+      } else {
+        aot++;
+      }
+    }
+    const total = aot + runtime;
+    return {
+      components: Object.fromEntries(this._components),
+      coverage: {
+        total,
+        aot,
+        runtime,
+        percentage: total === 0 ? 0 : Math.round(aot / total * 100)
+      },
+      divergences: [...this._divergences]
+    };
+  }
+}
+// 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 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;
+      }
+    }
+    currentManifest = { components };
+    updateDiagnostics(currentManifest, true);
+    rebuildCount++;
+    lastRebuildMs = Math.round(performance.now() - start);
+    lastRebuildAt = new Date().toISOString();
+  }
+  function incrementalUpdate(filePath, sourceText) {
+    if (!currentManifest)
+      return;
+    const start = performance.now();
+    const newComponents = { ...currentManifest.components };
+    for (const [name, entry] of Object.entries(newComponents)) {
+      if (entry.file === filePath) {
+        delete newComponents[name];
+      }
+    }
+    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.endsWith(".tsx"))
+        return;
+      incrementalUpdate(filePath, sourceText);
+    },
+    getManifest() {
+      return currentManifest;
+    },
+    getSnapshot() {
+      return {
+        manifest: currentManifest,
+        rebuildCount,
+        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)
+    return [];
+  const result = [];
+  for (const query of queries) {
+    const descriptor = reconstructSingle(query, routeParams, apiClient);
+    if (descriptor) {
+      result.push(descriptor);
+    }
+  }
+  return result;
+}
+function reconstructSingle(query, routeParams, apiClient) {
+  const { entity, operation } = query;
+  if (!entity || !operation)
+    return;
+  const entitySdk = apiClient[entity];
+  if (!entitySdk)
+    return;
+  const method = entitySdk[operation];
+  if (typeof method !== "function")
+    return;
+  const args = buildFactoryArgs(query, routeParams);
+  if (args === undefined)
+    return;
+  try {
+    const descriptor = method(...args);
+    if (!descriptor || typeof descriptor._key !== "string" || typeof descriptor._fetch !== "function") {
+      return;
+    }
+    return { key: descriptor._key, fetch: descriptor._fetch };
+  } catch {
+    return;
+  }
+}
+function buildFactoryArgs(query, routeParams) {
+  const { operation, idParam, queryBindings } = query;
+  if (operation === "get") {
+    if (idParam) {
+      const id = routeParams[idParam];
+      if (!id)
+        return;
+      const options = resolveQueryBindings(queryBindings, routeParams);
+      if (options === undefined && queryBindings)
+        return;
+      return options ? [id, options] : [id];
+    }
+    return;
+  }
+  if (!queryBindings)
+    return [];
+  const resolved = resolveQueryBindings(queryBindings, routeParams);
+  if (resolved === undefined)
+    return;
+  return [resolved];
+}
+function resolveQueryBindings(bindings, routeParams) {
+  if (!bindings)
+    return;
+  const resolved = {};
+  if (bindings.where) {
+    const where = {};
+    for (const [key, value] of Object.entries(bindings.where)) {
+      if (value === null)
+        return;
+      if (typeof value === "string" && value.startsWith("$")) {
+        const paramName = value.slice(1);
+        const paramValue = routeParams[paramName];
+        if (!paramValue)
+          return;
+        where[key] = paramValue;
+      } else {
+        where[key] = value;
+      }
+    }
+    resolved.where = where;
+  }
+  if (bindings.select)
+    resolved.select = bindings.select;
+  if (bindings.include)
+    resolved.include = bindings.include;
+  if (bindings.orderBy)
+    resolved.orderBy = bindings.orderBy;
+  if (bindings.limit !== undefined)
+    resolved.limit = bindings.limit;
+  return resolved;
+}
+
+// src/ssr-single-pass.ts
+async function ssrRenderSinglePass(module, url, options) {
+  if (options?.prefetch === false) {
+    return ssrRenderToString(module, url, options);
+  }
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  ensureDomShim();
+  const zeroDiscoveryData = attemptZeroDiscovery(normalizedUrl, module, options, ssrTimeout);
+  if (zeroDiscoveryData) {
+    return renderWithPrefetchedData(module, normalizedUrl, zeroDiscoveryData, options);
+  }
+  const discoveryCtx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    discoveryCtx.ssrAuth = options.ssrAuth;
+  }
+  const discoveredData = await ssrStorage.run(discoveryCtx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      createApp();
+      if (discoveryCtx.ssrRedirect) {
+        return { redirect: discoveryCtx.ssrRedirect };
+      }
+      if (discoveryCtx.pendingRouteComponents?.size) {
+        const entries = Array.from(discoveryCtx.pendingRouteComponents.entries());
+        const results = await Promise.allSettled(entries.map(([route, promise]) => Promise.race([
+          promise.then((mod) => ({ route, factory: mod.default })),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("lazy route timeout")), ssrTimeout))
+        ])));
+        discoveryCtx.resolvedComponents = new Map;
+        for (const result of results) {
+          if (result.status === "fulfilled") {
+            const { route, factory } = result.value;
+            discoveryCtx.resolvedComponents.set(route, factory);
+          }
+        }
+        discoveryCtx.pendingRouteComponents = undefined;
+      }
+      const queries = getSSRQueries();
+      const eligibleQueries = filterByEntityAccess(queries, options?.manifest?.entityAccess, options?.prefetchSession);
+      const resolvedQueries = [];
+      if (eligibleQueries.length > 0) {
+        await Promise.allSettled(eligibleQueries.map(({ promise, timeout, resolve, key }) => Promise.race([
+          promise.then((data) => {
+            resolve(data);
+            resolvedQueries.push({ key, data });
+            return "resolved";
+          }),
+          new Promise((r) => setTimeout(r, timeout || ssrTimeout)).then(() => "timeout")
+        ])));
+      }
+      return {
+        resolvedQueries,
+        resolvedComponents: discoveryCtx.resolvedComponents
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+  if ("redirect" in discoveredData) {
+    return {
+      html: "",
+      css: "",
+      ssrData: [],
+      headTags: "",
+      redirect: discoveredData.redirect
+    };
+  }
+  const renderCtx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    renderCtx.ssrAuth = options.ssrAuth;
+  }
+  for (const { key, data } of discoveredData.resolvedQueries) {
+    renderCtx.queryCache.set(key, data);
+  }
+  renderCtx.resolvedComponents = discoveredData.resolvedComponents ?? new Map;
+  return ssrStorage.run(renderCtx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileTheme2(module.theme, {
+            fallbackMetrics: options?.fallbackMetrics
+          });
+          themeCss = compiled.css;
+          themePreloadTags = compiled.preloadTags;
+        } catch (e) {
+          console.error("[vertz] Failed to compile theme export. Ensure your theme is created with defineTheme().", e);
+        }
+      }
+      const app = createApp();
+      const vnode = toVNode(app);
+      const stream = renderToStream(vnode);
+      const html = await streamToString(stream);
+      const css = collectCSS(themeCss, module);
+      const ssrData = discoveredData.resolvedQueries.map(({ key, data }) => ({
+        key,
+        data: JSON.parse(JSON.stringify(data))
+      }));
+      return {
+        html,
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        discoveredRoutes: renderCtx.discoveredRoutes,
+        matchedRoutePatterns: renderCtx.matchedRoutePatterns
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+function attemptZeroDiscovery(url, module, options, ssrTimeout) {
+  const manifest = options?.manifest;
+  if (!manifest?.routeEntries || !module.api)
+    return null;
+  const matches = matchUrlToPatterns(url, manifest.routePatterns);
+  if (matches.length === 0)
+    return null;
+  const allQueries = [];
+  let mergedParams = {};
+  for (const match of matches) {
+    const entry = manifest.routeEntries[match.pattern];
+    if (entry) {
+      allQueries.push(...entry.queries);
+    }
+    mergedParams = { ...mergedParams, ...match.params };
+  }
+  if (allQueries.length === 0)
+    return null;
+  const descriptors = reconstructDescriptors(allQueries, mergedParams, module.api);
+  if (descriptors.length === 0)
+    return null;
+  return prefetchFromDescriptors(descriptors, ssrTimeout);
+}
+async function prefetchFromDescriptors(descriptors, ssrTimeout) {
+  const resolvedQueries = [];
+  await Promise.allSettled(descriptors.map(({ key, fetch: fetchFn }) => Promise.race([
+    fetchFn().then((result) => {
+      const data = unwrapResult(result);
+      resolvedQueries.push({ key, data });
+      return "resolved";
+    }),
+    new Promise((r) => setTimeout(r, ssrTimeout)).then(() => "timeout")
+  ])));
+  return { resolvedQueries };
+}
+function unwrapResult(result) {
+  if (result && typeof result === "object" && "ok" in result && "data" in result) {
+    const r = result;
+    if (r.ok)
+      return r.data;
+  }
+  return result;
+}
+async function renderWithPrefetchedData(module, normalizedUrl, prefetchedData, options) {
+  const data = await prefetchedData;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  const renderCtx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    renderCtx.ssrAuth = options.ssrAuth;
+  }
+  for (const { key, data: queryData } of data.resolvedQueries) {
+    renderCtx.queryCache.set(key, queryData);
+  }
+  renderCtx.resolvedComponents = new Map;
+  return ssrStorage.run(renderCtx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileTheme2(module.theme, {
+            fallbackMetrics: options?.fallbackMetrics
+          });
+          themeCss = compiled.css;
+          themePreloadTags = compiled.preloadTags;
+        } catch (e) {
+          console.error("[vertz] Failed to compile theme export. Ensure your theme is created with defineTheme().", e);
+        }
+      }
+      const app = createApp();
+      const vnode = toVNode(app);
+      const stream = renderToStream(vnode);
+      const html = await streamToString(stream);
+      if (renderCtx.ssrRedirect) {
+        return {
+          html: "",
+          css: "",
+          ssrData: [],
+          headTags: "",
+          redirect: renderCtx.ssrRedirect,
+          discoveredRoutes: renderCtx.discoveredRoutes,
+          matchedRoutePatterns: renderCtx.matchedRoutePatterns
+        };
+      }
+      const css = collectCSS(themeCss, module);
+      const ssrData = data.resolvedQueries.map(({ key, data: d }) => ({
+        key,
+        data: JSON.parse(JSON.stringify(d))
+      }));
+      return {
+        html,
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        discoveredRoutes: renderCtx.discoveredRoutes,
+        matchedRoutePatterns: renderCtx.matchedRoutePatterns
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+var domShimInstalled = false;
+function ensureDomShim() {
+  if (domShimInstalled && typeof document !== "undefined")
+    return;
+  domShimInstalled = true;
+  installDomShim();
+}
+function resolveAppFactory(module) {
+  const createApp = module.default || module.App;
+  if (typeof createApp !== "function") {
+    throw new Error("App entry must export a default function or named App function");
+  }
+  return createApp;
+}
+function filterByEntityAccess(queries, entityAccess, session) {
+  if (!entityAccess || !session)
+    return queries;
+  return queries.filter(({ key }) => {
+    const entity = extractEntityFromKey(key);
+    const method = extractMethodFromKey(key);
+    if (!entity)
+      return true;
+    const entityRules = entityAccess[entity];
+    if (!entityRules)
+      return true;
+    const rule = entityRules[method];
+    if (!rule)
+      return true;
+    return evaluateAccessRule(rule, session);
+  });
+}
+function extractEntityFromKey(key) {
+  const pathStart = key.indexOf(":/");
+  if (pathStart === -1)
+    return;
+  const path = key.slice(pathStart + 2);
+  const firstSlash = path.indexOf("/");
+  const questionMark = path.indexOf("?");
+  if (firstSlash === -1 && questionMark === -1)
+    return path;
+  if (firstSlash === -1)
+    return path.slice(0, questionMark);
+  if (questionMark === -1)
+    return path.slice(0, firstSlash);
+  return path.slice(0, Math.min(firstSlash, questionMark));
+}
+function extractMethodFromKey(key) {
+  const pathStart = key.indexOf(":/");
+  if (pathStart === -1)
+    return "list";
+  const path = key.slice(pathStart + 2);
+  const cleanPath = path.split("?")[0] ?? "";
+  const segments = cleanPath.split("/").filter(Boolean);
+  return segments.length > 1 ? "get" : "list";
+}
+function collectCSS(themeCss, module) {
+  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>` : "";
+  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 {
@@ -457,11 +1406,131 @@ function generateSSRHtml(options) {
   </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,
   streamToString,
   ssrStorage,
   ssrRenderToString,
+  ssrRenderSinglePass,
+  ssrRenderAot,
   ssrDiscoverQueries,
   setGlobalSSRTimeout,
   serializeToHtml,
@@ -474,8 +1543,11 @@ export {
   renderHeadToHtml,
   renderAssetTags,
   registerSSRQuery,
+  reconstructDescriptors,
   rawHtml,
+  matchUrlToPatterns,
   isInSSR,
+  isAotDebugEnabled,
   inlineCriticalCss,
   getStreamingRuntimeScript,
   getSSRUrl,
@@ -483,7 +1555,9 @@ export {
   getGlobalSSRTimeout,
   getAccessSetForSSR,
   generateSSRHtml,
+  generateAotBuildManifest,
   extractFontMetrics,
+  evaluateAccessRule,
   encodeChunk,
   detectFallbackFont,
   createTemplateChunk,
@@ -492,8 +1566,16 @@ export {
   createSSRHandler,
   createSSRDataChunk,
   createSSRAdapter,
+  createPrefetchManifestManager,
+  createHoles,
+  createAotManifestManager,
   createAccessSetScript,
   collectStreamChunks,
   clearGlobalSSRTimeout,
-  HeadCollector
+  __ssr_style_object,
+  __ssr_spread,
+  __esc_attr,
+  __esc,
+  HeadCollector,
+  AotDiagnostics
 };