@vertz/ui-server 0.2.31 → 0.2.33

package/dist/index.js

@@ -1,13 +1,15 @@
 import {
-  createSSRHandler
-} from "./shared/chunk-wb5fv233.js";
+  createSSRHandler,
+  loadAotManifest
+} from "./shared/chunk-2kx402c1.js";
 import {
   createNodeHandler
-} from "./shared/chunk-es0406qq.js";
+} from "./shared/chunk-xdb8qn68.js";
 import {
   collectStreamChunks,
   compileThemeCached,
   createAccessSetScript,
+  createHoles,
   createRequestContext,
   createSSRDataChunk,
   createSessionScript,
@@ -19,6 +21,7 @@ import {
   evaluateAccessRule,
   getAccessSetForSSR,
   getStreamingRuntimeScript,
+  isAotDebugEnabled,
   matchUrlToPatterns,
   reconstructDescriptors,
   renderToStream,
@@ -26,32 +29,35 @@ import {
   safeSerialize,
   serializeToHtml,
   ssrDiscoverQueries,
+  ssrRenderAot,
   ssrRenderSinglePass,
   ssrRenderToString,
   streamToString,
   toPrefetchSession
-} from "./shared/chunk-34fexgex.js";
+} from "./shared/chunk-hx7drzm3.js";
 import {
   clearGlobalSSRTimeout,
   createSSRAdapter,
   getGlobalSSRTimeout,
   getSSRQueries,
   getSSRUrl,
-  installDomShim,
   isInSSR,
   rawHtml,
   registerSSRQuery,
   setGlobalSSRTimeout,
-  ssrStorage,
-  toVNode
+  ssrStorage
 } from "./shared/chunk-ybftdw1r.js";
 
+// src/index.ts
+import { extractRoutes } from "@vertz/ui-compiler";
+
 // src/aot-manifest-build.ts
 import { readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { compileForSSRAot } from "@vertz/ui-compiler";
 function generateAotBuildManifest(srcDir) {
   const components = {};
+  const compiledFiles = {};
   const classificationLog = [];
   const tsxFiles = collectTsxFiles(srcDir);
   for (const filePath of tsxFiles) {
@@ -61,7 +67,14 @@ function generateAotBuildManifest(srcDir) {
       for (const comp of result.components) {
         components[comp.name] = {
           tier: comp.tier,
-          holes: comp.holes
+          holes: comp.holes,
+          queryKeys: comp.queryKeys
+        };
+      }
+      if (result.components.length > 0) {
+        compiledFiles[filePath] = {
+          code: result.code,
+          components: result.components
         };
       }
     } catch (e) {
@@ -88,7 +101,61 @@ function generateAotBuildManifest(srcDir) {
     const pct = Math.round(aotCount / total * 100);
     classificationLog.push(`Coverage: ${aotCount}/${total} components (${pct}%)`);
   }
-  return { components, classificationLog };
+  return { components, compiledFiles, classificationLog };
+}
+function buildAotRouteMap(components, routes) {
+  const routeMap = {};
+  for (const route of routes) {
+    const comp = components[route.componentName];
+    if (!comp || comp.tier === "runtime-fallback")
+      continue;
+    routeMap[route.pattern] = {
+      renderFn: `__ssr_${route.componentName}`,
+      holes: comp.holes,
+      queryKeys: comp.queryKeys
+    };
+  }
+  return routeMap;
+}
+function generateAotBarrel(compiledFiles, routeMap) {
+  const neededFns = new Set;
+  for (const entry of Object.values(routeMap)) {
+    neededFns.add(entry.renderFn);
+  }
+  const fnToFile = new Map;
+  for (const [filePath, compiled] of Object.entries(compiledFiles)) {
+    for (const comp of compiled.components) {
+      const fnName = `__ssr_${comp.name}`;
+      if (neededFns.has(fnName)) {
+        fnToFile.set(fnName, filePath);
+      }
+    }
+  }
+  const fileToFns = new Map;
+  for (const [fnName, filePath] of fnToFile) {
+    const existing = fileToFns.get(filePath) ?? [];
+    existing.push(fnName);
+    fileToFns.set(filePath, existing);
+  }
+  const lines = [];
+  const files = {};
+  let fileIndex = 0;
+  for (const [filePath, fns] of fileToFns) {
+    const moduleName = basename(filePath, ".tsx").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const tempFileName = `__aot_${fileIndex}_${moduleName}`;
+    const moduleRef = `./${tempFileName}`;
+    lines.push(`export { ${fns.sort().join(", ")} } from '${moduleRef}';`);
+    const compiled = compiledFiles[filePath];
+    if (compiled) {
+      files[`${tempFileName}.tsx`] = compiled.code;
+    }
+    fileIndex++;
+  }
+  return {
+    barrelSource: lines.join(`
+`),
+    files
+  };
 }
 function collectTsxFiles(dir) {
   const files = [];
@@ -670,147 +737,6 @@ function createAotManifestManager(options) {
     }
   };
 }
-// 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, () => {
-        ensureDomShim();
-        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: 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 domShimInstalled = false;
-function ensureDomShim() {
-  if (domShimInstalled && typeof document !== "undefined")
-    return;
-  domShimInstalled = true;
-  installDomShim();
-}
-function collectCSSFromModule(module, fallbackMetrics) {
-  let themeCss = "";
-  let preloadTags = "";
-  if (module.theme) {
-    try {
-      const compiled = compileThemeCached(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",
@@ -1094,6 +1020,7 @@ export {
   reconstructDescriptors,
   rawHtml,
   matchUrlToPatterns,
+  loadAotManifest,
   isInSSR,
   isAotDebugEnabled,
   inlineCriticalCss,
@@ -1104,6 +1031,8 @@ export {
   getAccessSetForSSR,
   generateSSRHtml,
   generateAotBuildManifest,
+  generateAotBarrel,
+  extractRoutes,
   extractFontMetrics,
   evaluateAccessRule,
   encodeChunk,
@@ -1121,6 +1050,7 @@ export {
   createAccessSetScript,
   collectStreamChunks,
   clearGlobalSSRTimeout,
+  buildAotRouteMap,
   __ssr_style_object,
   __ssr_spread,
   __esc_attr,

package/dist/node-handler.d.ts

@@ -1,26 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import { FontFallbackMetrics as FontFallbackMetrics3 } from "@vertz/ui";
-import { CompiledRoute, Theme } from "@vertz/ui";
-interface SSRModule {
-	default?: () => unknown;
-	App?: () => unknown;
-	theme?: Theme;
-	/** Global CSS strings to include in every SSR response (e.g. resets, body styles). */
-	styles?: string[];
-	/**
-	* Return all CSS tracked by the bundled @vertz/ui instance.
-	* The Vite SSR build inlines @vertz/ui into the server bundle, creating
-	* a separate module instance from @vertz/ui-server's dependency. Without
-	* this, component CSS from module-level css() calls is invisible to the
-	* SSR renderer. Export `getInjectedCSS` from @vertz/ui in the app entry.
-	*/
-	getInjectedCSS?: () => string[];
-	/** Compiled routes exported from the app for build-time SSG with generateParams. */
-	routes?: CompiledRoute[];
-	/** Code-generated API client for manifest-driven zero-discovery prefetching. */
-	api?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
-}
-import { ExtractedQuery } from "@vertz/ui-compiler";
+import { FontFallbackMetrics as FontFallbackMetrics4 } from "@vertz/ui";
 /**
 * SSR prefetch access rule evaluator.
 *
@@ -60,6 +39,39 @@ type SerializedAccessRule = {
 } | {
 	type: "deny";
 };
+/**
+* Minimal session shape needed for prefetch access evaluation.
+* Extracted from the JWT at SSR request time.
+*/
+type PrefetchSession = {
+	status: "authenticated";
+	roles?: string[];
+	entitlements?: Record<string, boolean>;
+	tenantId?: string;
+} | {
+	status: "unauthenticated";
+};
+import { CompiledRoute, Theme } from "@vertz/ui";
+interface SSRModule {
+	default?: () => unknown;
+	App?: () => unknown;
+	theme?: Theme;
+	/** Global CSS strings to include in every SSR response (e.g. resets, body styles). */
+	styles?: string[];
+	/**
+	* Return all CSS tracked by the bundled @vertz/ui instance.
+	* The Vite SSR build inlines @vertz/ui into the server bundle, creating
+	* a separate module instance from @vertz/ui-server's dependency. Without
+	* this, component CSS from module-level css() calls is invisible to the
+	* SSR renderer. Export `getInjectedCSS` from @vertz/ui in the app entry.
+	*/
+	getInjectedCSS?: () => string[];
+	/** Compiled routes exported from the app for build-time SSG with generateParams. */
+	routes?: CompiledRoute[];
+	/** Code-generated API client for manifest-driven zero-discovery prefetching. */
+	api?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
+}
+import { ExtractedQuery } from "@vertz/ui-compiler";
 /** Serialized entity access rules from the prefetch manifest. */
 type EntityAccessMap = Record<string, Partial<Record<string, SerializedAccessRule>>>;
 interface SSRPrefetchManifest {
@@ -72,6 +84,37 @@ interface SSRPrefetchManifest {
 		queries: ExtractedQuery[];
 	}>;
 }
+/** Context passed to AOT render functions for accessing data and runtime holes. */
+interface SSRAotContext {
+	/** Pre-generated closures for runtime-rendered components. */
+	holes: Record<string, () => string>;
+	/** Access query data by cache key. */
+	getData(key: string): unknown;
+	/** Auth session for conditional rendering. */
+	session: PrefetchSession | undefined;
+	/** Route params for the current request. */
+	params: Record<string, string>;
+}
+/** An AOT render function: takes props/data and context, returns HTML string. */
+type AotRenderFn = (data: Record<string, unknown>, ctx: SSRAotContext) => string;
+/** Per-route AOT entry in the manifest. */
+interface AotRouteEntry {
+	/** The pre-compiled render function. */
+	render: AotRenderFn;
+	/** Component names that need runtime fallback (holes). */
+	holes: string[];
+	/** Query cache keys this route reads via ctx.getData(). */
+	queryKeys?: string[];
+}
+/**
+* AOT manifest — maps route patterns to pre-compiled render functions.
+*
+* Generated at build time by the AOT compiler pipeline.
+*/
+interface AotManifest {
+	/** Route pattern → AOT entry. */
+	routes: Record<string, AotRouteEntry>;
+}
 import { AccessSet } from "@vertz/ui/auth";
 interface SessionData {
 	user: {
@@ -125,7 +168,7 @@ interface SSRHandlerOptions {
 	*/
 	nonce?: string;
 	/** Pre-computed font fallback metrics (computed at server startup). */
-	fallbackMetrics?: Record<string, FontFallbackMetrics3>;
+	fallbackMetrics?: Record<string, FontFallbackMetrics4>;
 	/** Paths to inject as `<link rel="modulepreload">` in `<head>`. */
 	modulepreload?: string[];
 	/**
@@ -164,6 +207,16 @@ interface SSRHandlerOptions {
 	* which always use buffered rendering.
 	*/
 	progressiveHTML?: boolean;
+	/**
+	* AOT manifest with pre-compiled render functions.
+	*
+	* When provided, routes matching AOT entries are rendered via string-builder
+	* functions (no DOM shim), bypassing the reactive runtime for 4-6x speedup.
+	* Routes not in the manifest fall back to `ssrRenderSinglePass()`.
+	*
+	* Load via `loadAotManifest(serverDir)` at startup.
+	*/
+	aotManifest?: AotManifest;
 }
 type NodeHandlerOptions = SSRHandlerOptions;
 declare function createNodeHandler(options: NodeHandlerOptions): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/node-handler.js

@@ -1,7 +1,7 @@
 import {
   createNodeHandler
-} from "./shared/chunk-es0406qq.js";
-import"./shared/chunk-34fexgex.js";
+} from "./shared/chunk-xdb8qn68.js";
+import"./shared/chunk-hx7drzm3.js";
 import"./shared/chunk-ybftdw1r.js";
 export {
   createNodeHandler

package/dist/shared/{chunk-wb5fv233.js → chunk-2kx402c1.js}

@@ -6,10 +6,54 @@ import {
   resolveRouteModulepreload,
   resolveSession,
   safeSerialize,
+  ssrRenderAot,
   ssrRenderProgressive,
   ssrRenderSinglePass,
-  ssrStreamNavQueries
-} from "./chunk-34fexgex.js";
+  ssrStreamNavQueries,
+  toPrefetchSession
+} from "./chunk-hx7drzm3.js";
+
+// src/aot-manifest-loader.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+async function loadAotManifest(serverDir) {
+  const manifestPath = join(serverDir, "aot-manifest.json");
+  const routesModulePath = join(serverDir, "aot-routes.js");
+  if (!existsSync(manifestPath) || !existsSync(routesModulePath)) {
+    return null;
+  }
+  let manifestJson;
+  try {
+    const raw = readFileSync(manifestPath, "utf-8");
+    manifestJson = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!manifestJson.routes || Object.keys(manifestJson.routes).length === 0) {
+    return null;
+  }
+  let routesModule;
+  try {
+    routesModule = await import(routesModulePath);
+  } catch {
+    return null;
+  }
+  const routes = {};
+  for (const [pattern, entry] of Object.entries(manifestJson.routes)) {
+    const renderFn = routesModule[entry.renderFn];
+    if (typeof renderFn !== "function")
+      continue;
+    routes[pattern] = {
+      render: renderFn,
+      holes: entry.holes,
+      queryKeys: entry.queryKeys
+    };
+  }
+  if (Object.keys(routes).length === 0) {
+    return null;
+  }
+  return { routes };
+}
 
 // src/ssr-progressive-response.ts
 function buildProgressiveResponse(options) {
@@ -63,7 +107,8 @@ function createSSRHandler(options) {
     cacheControl,
     sessionResolver,
     manifest,
-    progressiveHTML
+    progressiveHTML,
+    aotManifest
   } = options;
   const { template, linkHeader, modulepreloadTags, splitResult } = precomputeHandlerState(options);
   return async (request) => {
@@ -83,7 +128,7 @@ function createSSRHandler(options) {
     if (useProgressive) {
       return handleProgressiveHTMLRequest(module, splitResult, pathname + url.search, ssrTimeout, nonce, fallbackMetrics, linkHeader, modulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest);
     }
-    return handleHTMLRequest(module, template, pathname + url.search, ssrTimeout, nonce, fallbackMetrics, linkHeader, modulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest);
+    return handleHTMLRequest(module, template, pathname + url.search, ssrTimeout, nonce, fallbackMetrics, linkHeader, modulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest, aotManifest);
   };
 }
 async function handleNavRequest(module, url, ssrTimeout) {
@@ -172,13 +217,22 @@ async function handleProgressiveHTMLRequest(module, split, url, ssrTimeout, nonc
     });
   }
 }
-async function handleHTMLRequest(module, template, url, ssrTimeout, nonce, fallbackMetrics, linkHeader, staticModulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest) {
+async function handleHTMLRequest(module, template, url, ssrTimeout, nonce, fallbackMetrics, linkHeader, staticModulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest, aotManifest) {
   try {
-    const result = await ssrRenderSinglePass(module, url, {
+    const prefetchSession = ssrAuth ? toPrefetchSession(ssrAuth) : undefined;
+    const result = aotManifest ? await ssrRenderAot(module, url, {
+      aotManifest,
+      manifest,
       ssrTimeout,
       fallbackMetrics,
       ssrAuth,
-      manifest
+      prefetchSession
+    }) : await ssrRenderSinglePass(module, url, {
+      ssrTimeout,
+      fallbackMetrics,
+      ssrAuth,
+      manifest,
+      prefetchSession
     });
     if (result.redirect) {
       return new Response(null, {
@@ -213,4 +267,4 @@ async function handleHTMLRequest(module, template, url, ssrTimeout, nonce, fallb
   }
 }
 
-export { createSSRHandler };
+export { loadAotManifest, createSSRHandler };