@vertz/ui-server 0.2.31 → 0.2.32

package/dist/shared/chunk-gbcsa7h1.js

@@ -0,0 +1,471 @@
+import {
+  compileThemeCached,
+  createRequestContext,
+  encodeChunk,
+  escapeAttr,
+  injectIntoTemplate,
+  matchUrlToPatterns,
+  precomputeHandlerState,
+  reconstructDescriptors,
+  resolveRouteModulepreload,
+  resolveSession,
+  safeSerialize,
+  serializeToHtml,
+  ssrRenderProgressive,
+  ssrRenderSinglePass,
+  ssrStreamNavQueries,
+  toPrefetchSession
+} from "./chunk-34fexgex.js";
+import {
+  clearGlobalSSRTimeout,
+  installDomShim,
+  setGlobalSSRTimeout,
+  ssrStorage,
+  toVNode
+} from "./chunk-ybftdw1r.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-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;
+  if (aotEntry.queryKeys && aotEntry.queryKeys.length > 0 && manifest?.routeEntries) {
+    const apiClient = module.api;
+    if (apiClient) {
+      await prefetchForAot(aotEntry.queryKeys, manifest.routeEntries, match, apiClient, ssrTimeout, queryCache);
+    }
+  }
+  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,
+      matchedRoutePatterns: [match.pattern]
+    };
+  } finally {
+    clearGlobalSSRTimeout();
+  }
+}
+async function prefetchForAot(queryKeys, routeEntries, match, apiClient, ssrTimeout, queryCache) {
+  const entry = routeEntries[match.pattern];
+  if (!entry)
+    return;
+  const queryKeySet = new Set(queryKeys);
+  const fetchJobs = [];
+  for (const query of entry.queries) {
+    if (!query.entity || !query.operation)
+      continue;
+    const aotKey = `${query.entity}-${query.operation}`;
+    if (!queryKeySet.has(aotKey))
+      continue;
+    const descriptors = reconstructDescriptors([query], match.params, apiClient);
+    if (descriptors.length > 0 && descriptors[0]) {
+      fetchJobs.push({ aotKey, fetchFn: descriptors[0].fetch });
+    }
+  }
+  if (fetchJobs.length === 0)
+    return;
+  await Promise.allSettled(fetchJobs.map(({ aotKey, fetchFn }) => {
+    let timer;
+    return Promise.race([
+      fetchFn().then((result) => {
+        clearTimeout(timer);
+        const data = unwrapResult(result);
+        queryCache.set(aotKey, data);
+      }),
+      new Promise((r) => {
+        timer = setTimeout(r, ssrTimeout);
+      })
+    ]);
+  }));
+}
+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;
+}
+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-progressive-response.ts
+function buildProgressiveResponse(options) {
+  const { headChunk, renderStream, tailChunk, ssrData, nonce, headers } = options;
+  const stream = new ReadableStream({
+    async start(controller) {
+      controller.enqueue(encodeChunk(headChunk));
+      const reader = renderStream.getReader();
+      let renderError;
+      try {
+        for (;; ) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          controller.enqueue(value);
+        }
+      } catch (err) {
+        renderError = err instanceof Error ? err : new Error(String(err));
+      }
+      if (renderError) {
+        console.error("[SSR] Render error after head sent:", renderError.message);
+        const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+        const errorScript = `<script${nonceAttr}>document.dispatchEvent(new CustomEvent('vertz:ssr-error',` + `{detail:{message:${safeSerialize(renderError.message)}}}))</script>`;
+        controller.enqueue(encodeChunk(errorScript));
+      }
+      let tail = "";
+      if (ssrData.length > 0) {
+        const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+        tail += `<script${nonceAttr}>window.__VERTZ_SSR_DATA__=${safeSerialize(ssrData)};</script>`;
+      }
+      tail += tailChunk;
+      controller.enqueue(encodeChunk(tail));
+      controller.close();
+    }
+  });
+  const responseHeaders = {
+    "Content-Type": "text/html; charset=utf-8",
+    ...headers
+  };
+  return new Response(stream, { status: 200, headers: responseHeaders });
+}
+
+// src/ssr-handler.ts
+function createSSRHandler(options) {
+  const {
+    module,
+    ssrTimeout,
+    nonce,
+    fallbackMetrics,
+    routeChunkManifest,
+    cacheControl,
+    sessionResolver,
+    manifest,
+    progressiveHTML,
+    aotManifest
+  } = options;
+  const { template, linkHeader, modulepreloadTags, splitResult } = precomputeHandlerState(options);
+  return async (request) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    if (request.headers.get("x-vertz-nav") === "1") {
+      return handleNavRequest(module, pathname, ssrTimeout);
+    }
+    let sessionScript = "";
+    let ssrAuth;
+    if (sessionResolver) {
+      const result = await resolveSession(request, sessionResolver, nonce);
+      sessionScript = result.sessionScript;
+      ssrAuth = result.ssrAuth;
+    }
+    const useProgressive = progressiveHTML && splitResult && !(manifest?.routeEntries && Object.keys(manifest.routeEntries).length > 0);
+    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, aotManifest);
+  };
+}
+async function handleNavRequest(module, url, ssrTimeout) {
+  try {
+    const stream = await ssrStreamNavQueries(module, url, { ssrTimeout });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+  } catch {
+    return new Response(`event: done
+data: {}
+
+`, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+  }
+}
+async function handleProgressiveHTMLRequest(module, split, url, ssrTimeout, nonce, fallbackMetrics, linkHeader, staticModulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest) {
+  try {
+    const result = await ssrRenderProgressive(module, url, {
+      ssrTimeout,
+      fallbackMetrics,
+      ssrAuth,
+      manifest
+    });
+    if (result.redirect) {
+      return new Response(null, {
+        status: 302,
+        headers: { Location: result.redirect.to }
+      });
+    }
+    const modulepreloadTags = resolveRouteModulepreload(routeChunkManifest, result.matchedRoutePatterns, staticModulepreloadTags);
+    let headChunk = split.headTemplate;
+    const headCloseIdx = headChunk.lastIndexOf("</head>");
+    if (headCloseIdx !== -1) {
+      const injections = [];
+      if (result.css)
+        injections.push(result.css);
+      if (result.headTags)
+        injections.push(result.headTags);
+      if (modulepreloadTags)
+        injections.push(modulepreloadTags);
+      if (sessionScript)
+        injections.push(sessionScript);
+      if (injections.length > 0) {
+        headChunk = headChunk.slice(0, headCloseIdx) + injections.join(`
+`) + `
+` + headChunk.slice(headCloseIdx);
+      }
+    } else {
+      if (result.css)
+        headChunk += result.css;
+      if (result.headTags)
+        headChunk += result.headTags;
+      if (modulepreloadTags)
+        headChunk += modulepreloadTags;
+      if (sessionScript)
+        headChunk += sessionScript;
+    }
+    const headers = {};
+    if (linkHeader)
+      headers.Link = linkHeader;
+    if (cacheControl)
+      headers["Cache-Control"] = cacheControl;
+    return buildProgressiveResponse({
+      headChunk,
+      renderStream: result.renderStream,
+      tailChunk: split.tailTemplate,
+      ssrData: result.ssrData,
+      nonce,
+      headers
+    });
+  } catch (err) {
+    console.error("[SSR] Render failed:", err instanceof Error ? err.message : err);
+    return new Response("Internal Server Error", {
+      status: 500,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+}
+async function handleHTMLRequest(module, template, url, ssrTimeout, nonce, fallbackMetrics, linkHeader, staticModulepreloadTags, routeChunkManifest, cacheControl, sessionScript, ssrAuth, manifest, aotManifest) {
+  try {
+    const prefetchSession = ssrAuth ? toPrefetchSession(ssrAuth) : undefined;
+    const result = aotManifest ? await ssrRenderAot(module, url, {
+      aotManifest,
+      manifest,
+      ssrTimeout,
+      fallbackMetrics,
+      ssrAuth,
+      prefetchSession
+    }) : await ssrRenderSinglePass(module, url, {
+      ssrTimeout,
+      fallbackMetrics,
+      ssrAuth,
+      manifest,
+      prefetchSession
+    });
+    if (result.redirect) {
+      return new Response(null, {
+        status: 302,
+        headers: { Location: result.redirect.to }
+      });
+    }
+    const modulepreloadTags = resolveRouteModulepreload(routeChunkManifest, result.matchedRoutePatterns, staticModulepreloadTags);
+    const allHeadTags = [result.headTags, modulepreloadTags].filter(Boolean).join(`
+`);
+    const html = injectIntoTemplate({
+      template,
+      appHtml: result.html,
+      appCss: result.css,
+      ssrData: result.ssrData,
+      nonce,
+      headTags: allHeadTags || undefined,
+      sessionScript
+    });
+    const headers = { "Content-Type": "text/html; charset=utf-8" };
+    if (linkHeader)
+      headers.Link = linkHeader;
+    if (cacheControl)
+      headers["Cache-Control"] = cacheControl;
+    return new Response(html, { status: 200, headers });
+  } catch (err) {
+    console.error("[SSR] Render failed:", err instanceof Error ? err.message : err);
+    return new Response("Internal Server Error", {
+      status: 500,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+}
+
+export { loadAotManifest, createHoles, ssrRenderAot, isAotDebugEnabled, createSSRHandler };

package/dist/ssr/index.d.ts

@@ -1,4 +1,54 @@
-import { CompiledRoute as CompiledRoute2, FontFallbackMetrics as FontFallbackMetrics2 } from "@vertz/ui";
+/**
+* SSR prefetch access rule evaluator.
+*
+* Evaluates serialized entity access rules against the current session
+* to determine whether a query should be prefetched during SSR.
+*
+* The serialized rules come from the prefetch manifest (generated at build time).
+* The session comes from the JWT decoded at request time.
+*/
+/**
+* Serialized access rule — the JSON-friendly format stored in the manifest.
+* Mirrors SerializedRule from @vertz/server/auth/rules but defined here
+* to avoid importing the server package into the SSR pipeline.
+*/
+type SerializedAccessRule = {
+	type: "public";
+} | {
+	type: "authenticated";
+} | {
+	type: "role";
+	roles: string[];
+} | {
+	type: "entitlement";
+	value: string;
+} | {
+	type: "where";
+	conditions: Record<string, unknown>;
+} | {
+	type: "all";
+	rules: SerializedAccessRule[];
+} | {
+	type: "any";
+	rules: SerializedAccessRule[];
+} | {
+	type: "fva";
+	maxAge: number;
+} | {
+	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, FontFallbackMetrics, Theme } from "@vertz/ui";
 import { SSRAuth as SSRAuth_jq1nwm } from "@vertz/ui/internals";
 interface SSRModule {
@@ -67,6 +117,60 @@ declare function ssrRenderToString(module: SSRModule, url: string, options?: {
 declare function ssrDiscoverQueries(module: SSRModule, url: string, options?: {
 	ssrTimeout?: number;
 }): Promise<SSRDiscoverResult>;
+import { ExtractedQuery } from "@vertz/ui-compiler";
+/** Serialized entity access rules from the prefetch manifest. */
+type EntityAccessMap = Record<string, Partial<Record<string, SerializedAccessRule>>>;
+interface SSRPrefetchManifest {
+	/** Route patterns present in the manifest. */
+	routePatterns: string[];
+	/** Entity access rules keyed by entity name → operation → serialized rule. */
+	entityAccess?: EntityAccessMap;
+	/** Route entries with query binding metadata for zero-discovery prefetch. */
+	routeEntries?: Record<string, {
+		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>;
+}
+/**
+* Load AOT manifest and routes module from a server build directory.
+*
+* Returns `null` if either `aot-manifest.json` or `aot-routes.js` is missing,
+* or if no routes can be wired to render functions.
+*
+* @param serverDir - Path to `dist/server/` directory
+*/
+declare function loadAotManifest(serverDir: string): Promise<AotManifest | null>;
+import { CompiledRoute as CompiledRoute2, FontFallbackMetrics as FontFallbackMetrics4 } from "@vertz/ui";
 interface PrerenderResult {
 	/** The route path that was pre-rendered. */
 	path: string;
@@ -79,7 +183,7 @@ interface PrerenderOptions {
 	/** CSP nonce for inline scripts. */
 	nonce?: string;
 	/** Pre-computed font fallback metrics for zero-CLS font loading. */
-	fallbackMetrics?: Record<string, FontFallbackMetrics2>;
+	fallbackMetrics?: Record<string, FontFallbackMetrics4>;
 }
 /**
 * Discover all route patterns from an SSR module.
@@ -128,59 +232,7 @@ declare function stripScriptsFromStaticHTML(html: string): string;
 * - Routes without `prerender` or `generateParams` are not collected
 */
 declare function collectPrerenderPaths(routes: CompiledRoute2[], prefix?: string): Promise<string[]>;
-import { FontFallbackMetrics as FontFallbackMetrics4 } from "@vertz/ui";
-import { ExtractedQuery } from "@vertz/ui-compiler";
-/**
-* SSR prefetch access rule evaluator.
-*
-* Evaluates serialized entity access rules against the current session
-* to determine whether a query should be prefetched during SSR.
-*
-* The serialized rules come from the prefetch manifest (generated at build time).
-* The session comes from the JWT decoded at request time.
-*/
-/**
-* Serialized access rule — the JSON-friendly format stored in the manifest.
-* Mirrors SerializedRule from @vertz/server/auth/rules but defined here
-* to avoid importing the server package into the SSR pipeline.
-*/
-type SerializedAccessRule = {
-	type: "public";
-} | {
-	type: "authenticated";
-} | {
-	type: "role";
-	roles: string[];
-} | {
-	type: "entitlement";
-	value: string;
-} | {
-	type: "where";
-	conditions: Record<string, unknown>;
-} | {
-	type: "all";
-	rules: SerializedAccessRule[];
-} | {
-	type: "any";
-	rules: SerializedAccessRule[];
-} | {
-	type: "fva";
-	maxAge: number;
-} | {
-	type: "deny";
-};
-/** Serialized entity access rules from the prefetch manifest. */
-type EntityAccessMap = Record<string, Partial<Record<string, SerializedAccessRule>>>;
-interface SSRPrefetchManifest {
-	/** Route patterns present in the manifest. */
-	routePatterns: string[];
-	/** Entity access rules keyed by entity name → operation → serialized rule. */
-	entityAccess?: EntityAccessMap;
-	/** Route entries with query binding metadata for zero-discovery prefetch. */
-	routeEntries?: Record<string, {
-		queries: ExtractedQuery[];
-	}>;
-}
+import { FontFallbackMetrics as FontFallbackMetrics5 } from "@vertz/ui";
 import { AccessSet } from "@vertz/ui/auth";
 interface SessionData {
 	user: {
@@ -234,7 +286,7 @@ interface SSRHandlerOptions {
 	*/
 	nonce?: string;
 	/** Pre-computed font fallback metrics (computed at server startup). */
-	fallbackMetrics?: Record<string, FontFallbackMetrics4>;
+	fallbackMetrics?: Record<string, FontFallbackMetrics5>;
 	/** Paths to inject as `<link rel="modulepreload">` in `<head>`. */
 	modulepreload?: string[];
 	/**
@@ -273,6 +325,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;
 }
 declare function createSSRHandler(options: SSRHandlerOptions): (request: Request) => Promise<Response>;
 interface InjectIntoTemplateOptions {
@@ -295,4 +357,4 @@ interface InjectIntoTemplateOptions {
 * injects CSS before </head>, and ssrData before </body>.
 */
 declare function injectIntoTemplate(options: InjectIntoTemplateOptions): string;
-export { stripScriptsFromStaticHTML, ssrRenderToString, ssrDiscoverQueries, prerenderRoutes, injectIntoTemplate, filterPrerenderableRoutes, discoverRoutes, createSSRHandler, collectPrerenderPaths, SSRRenderResult, SSRModule, SSRHandlerOptions, SSRDiscoverResult, PrerenderResult, PrerenderOptions };
+export { stripScriptsFromStaticHTML, ssrRenderToString, ssrDiscoverQueries, prerenderRoutes, loadAotManifest, injectIntoTemplate, filterPrerenderableRoutes, discoverRoutes, createSSRHandler, collectPrerenderPaths, SSRRenderResult, SSRModule, SSRHandlerOptions, SSRDiscoverResult, PrerenderResult, PrerenderOptions };

package/dist/ssr/index.js

@@ -1,13 +1,13 @@
 import {
-  createSSRHandler
-} from "../shared/chunk-wb5fv233.js";
+  createSSRHandler,
+  loadAotManifest
+} from "../shared/chunk-gbcsa7h1.js";
 import {
   injectIntoTemplate,
   ssrDiscoverQueries,
   ssrRenderToString
 } from "../shared/chunk-34fexgex.js";
 import"../shared/chunk-ybftdw1r.js";
-
 // src/prerender.ts
 async function discoverRoutes(module) {
   const result = await ssrRenderToString(module, "/");
@@ -115,6 +115,7 @@ export {
   ssrRenderToString,
   ssrDiscoverQueries,
   prerenderRoutes,
+  loadAotManifest,
   injectIntoTemplate,
   filterPrerenderableRoutes,
   discoverRoutes,