@vertz/ui-server 0.2.28 → 0.2.30

package/dist/shared/chunk-bd0sgykf.js

@@ -0,0 +1,1468 @@
+import {
+  clearGlobalSSRTimeout,
+  createSSRAdapter,
+  getSSRQueries,
+  installDomShim,
+  setGlobalSSRTimeout,
+  ssrStorage,
+  toVNode
+} from "./chunk-gcwqkynf.js";
+
+// src/html-serializer.ts
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(value) {
+  const str = typeof value === "string" ? value : String(value);
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function serializeAttrs(attrs) {
+  const parts = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    parts.push(` ${key}="${escapeAttr(value)}"`);
+  }
+  return parts.join("");
+}
+function isRawHtml(value) {
+  return typeof value === "object" && "__raw" in value && value.__raw === true;
+}
+function serializeToHtml(node) {
+  if (typeof node === "string") {
+    return escapeHtml(node);
+  }
+  if (isRawHtml(node)) {
+    return node.html;
+  }
+  const { tag, attrs, children } = node;
+  if (tag === "fragment") {
+    return children.map((child) => serializeToHtml(child)).join("");
+  }
+  const attrStr = serializeAttrs(attrs);
+  if (VOID_ELEMENTS.has(tag)) {
+    return `<${tag}${attrStr}>`;
+  }
+  const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+  const childrenHtml = children.map((child) => {
+    if (typeof child === "string" && isRawText) {
+      return child;
+    }
+    return serializeToHtml(child);
+  }).join("");
+  return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+}
+
+// src/slot-placeholder.ts
+var slotCounter = 0;
+function resetSlotCounter() {
+  slotCounter = 0;
+}
+function createSlotPlaceholder(fallback) {
+  const id = slotCounter++;
+  const placeholder = {
+    tag: "div",
+    attrs: { id: `v-slot-${id}` },
+    children: typeof fallback === "string" ? [fallback] : [fallback],
+    _slotId: id
+  };
+  return placeholder;
+}
+
+// src/streaming.ts
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function encodeChunk(html) {
+  return encoder.encode(html);
+}
+async function streamToString(stream) {
+  const reader = stream.getReader();
+  const parts = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    parts.push(decoder.decode(value, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function collectStreamChunks(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(decoder.decode(value, { stream: true }));
+  }
+  return chunks;
+}
+
+// src/template-chunk.ts
+function createTemplateChunk(slotId, resolvedHtml, nonce) {
+  const tmplId = `v-tmpl-${slotId}`;
+  const slotRef = `v-slot-${slotId}`;
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<template id="${tmplId}">${resolvedHtml}</template>` + `<script${nonceAttr}>` + `(function(){` + `var s=document.getElementById("${slotRef}");` + `var t=document.getElementById("${tmplId}");` + `if(s&&t){s.replaceWith(t.content.cloneNode(true));t.remove()}` + `})()` + "</script>";
+}
+
+// src/render-to-stream.ts
+function isSuspenseNode(node) {
+  return typeof node === "object" && "tag" in node && node.tag === "__suspense" && "_resolve" in node;
+}
+function renderToStream(tree, options) {
+  const pendingBoundaries = [];
+  function walkAndSerialize(node) {
+    if (typeof node === "string") {
+      return escapeHtml(node);
+    }
+    if (isRawHtml(node)) {
+      return node.html;
+    }
+    if (isSuspenseNode(node)) {
+      const placeholder = createSlotPlaceholder(node._fallback);
+      pendingBoundaries.push({
+        slotId: placeholder._slotId,
+        resolve: node._resolve
+      });
+      return serializeToHtml(placeholder);
+    }
+    const { tag, attrs, children } = node;
+    if (tag === "fragment") {
+      return children.map((child) => walkAndSerialize(child)).join("");
+    }
+    const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+    const attrStr = Object.entries(attrs).map(([k, v]) => ` ${k}="${escapeAttr(v)}"`).join("");
+    if (VOID_ELEMENTS.has(tag)) {
+      return `<${tag}${attrStr}>`;
+    }
+    const childrenHtml = children.map((child) => {
+      if (typeof child === "string" && isRawText) {
+        return child;
+      }
+      return walkAndSerialize(child);
+    }).join("");
+    return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      const mainHtml = walkAndSerialize(tree);
+      controller.enqueue(encodeChunk(mainHtml));
+      if (pendingBoundaries.length > 0) {
+        const nonce = options?.nonce;
+        const resolutions = pendingBoundaries.map(async (boundary) => {
+          try {
+            const resolved = await boundary.resolve;
+            const resolvedHtml = serializeToHtml(resolved);
+            return createTemplateChunk(boundary.slotId, resolvedHtml, nonce);
+          } catch (_err) {
+            const errorHtml = `<div data-v-ssr-error="true" id="v-ssr-error-${boundary.slotId}">` + "<!--SSR error--></div>";
+            return createTemplateChunk(boundary.slotId, errorHtml, nonce);
+          }
+        });
+        const chunks = await Promise.all(resolutions);
+        for (const chunk of chunks) {
+          controller.enqueue(encodeChunk(chunk));
+        }
+      }
+      controller.close();
+    }
+  });
+}
+
+// src/ssr-streaming-runtime.ts
+function safeSerialize(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+function getStreamingRuntimeScript(nonce) {
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<script${nonceAttr}>` + "window.__VERTZ_SSR_DATA__=[];" + "window.__VERTZ_SSR_PUSH__=function(k,d){" + "window.__VERTZ_SSR_DATA__.push({key:k,data:d});" + 'document.dispatchEvent(new CustomEvent("vertz:ssr-data",{detail:{key:k,data:d}}))' + "};" + "</script>";
+}
+function createSSRDataChunk(key, data, nonce) {
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  const serialized = safeSerialize(data);
+  return `<script${nonceAttr}>window.__VERTZ_SSR_PUSH__(${safeSerialize(key)},${serialized})</script>`;
+}
+
+// src/ssr-render.ts
+import { compileTheme } from "@vertz/ui";
+import { EntityStore, MemoryCache, QueryEnvelopeStore } from "@vertz/ui/internals";
+var compiledThemeCache = new WeakMap;
+function compileThemeCached(theme, fallbackMetrics) {
+  const cached = compiledThemeCache.get(theme);
+  if (cached)
+    return cached;
+  const compiled = compileTheme(theme, { fallbackMetrics });
+  compiledThemeCache.set(theme, compiled);
+  return compiled;
+}
+function createRequestContext(url) {
+  return {
+    url,
+    adapter: createSSRAdapter(),
+    subscriber: null,
+    readValueCb: null,
+    cleanupStack: [],
+    batchDepth: 0,
+    pendingEffects: new Map,
+    contextScope: null,
+    entityStore: new EntityStore,
+    envelopeStore: new QueryEnvelopeStore,
+    queryCache: new MemoryCache({ maxSize: Infinity }),
+    inflight: new Map,
+    queries: [],
+    errors: []
+  };
+}
+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 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(`
+`);
+}
+async function ssrRenderToString(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  ensureDomShim();
+  const ctx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    ctx.ssrAuth = options.ssrAuth;
+  }
+  return ssrStorage.run(ctx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileThemeCached(module.theme, 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);
+        }
+      }
+      createApp();
+      if (ctx.ssrRedirect) {
+        return {
+          html: "",
+          css: "",
+          ssrData: [],
+          headTags: "",
+          redirect: ctx.ssrRedirect
+        };
+      }
+      const store = ssrStorage.getStore();
+      if (store) {
+        if (store.pendingRouteComponents?.size) {
+          const entries = Array.from(store.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))
+          ])));
+          store.resolvedComponents = new Map;
+          for (const result of results) {
+            if (result.status === "fulfilled") {
+              const { route, factory } = result.value;
+              store.resolvedComponents.set(route, factory);
+            }
+          }
+          store.pendingRouteComponents = undefined;
+        }
+        if (!store.resolvedComponents) {
+          store.resolvedComponents = new Map;
+        }
+      }
+      const queries = getSSRQueries();
+      const resolvedQueries = [];
+      if (queries.length > 0) {
+        await Promise.allSettled(queries.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")
+        ])));
+        if (store)
+          store.queries = [];
+      }
+      const app = createApp();
+      const vnode = toVNode(app);
+      const stream = renderToStream(vnode);
+      const html = await streamToString(stream);
+      const css = collectCSS(themeCss, module);
+      const ssrData = resolvedQueries.length > 0 ? resolvedQueries.map(({ key, data }) => ({ key, data })) : [];
+      return {
+        html,
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        discoveredRoutes: ctx.discoveredRoutes,
+        matchedRoutePatterns: ctx.matchedRoutePatterns
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+async function ssrDiscoverQueries(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  ensureDomShim();
+  const ctx = createRequestContext(normalizedUrl);
+  return ssrStorage.run(ctx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      createApp();
+      const queries = getSSRQueries();
+      const resolvedQueries = [];
+      const pendingKeys = [];
+      if (queries.length > 0) {
+        await Promise.allSettled(queries.map(({ promise, timeout, resolve, key }) => {
+          let settled = false;
+          return Promise.race([
+            promise.then((data) => {
+              if (settled)
+                return "late";
+              settled = true;
+              resolve(data);
+              resolvedQueries.push({ key, data });
+              return "resolved";
+            }),
+            new Promise((r) => setTimeout(r, timeout || ssrTimeout)).then(() => {
+              if (settled)
+                return "already-resolved";
+              settled = true;
+              pendingKeys.push(key);
+              return "timeout";
+            })
+          ]);
+        }));
+      }
+      return {
+        resolved: resolvedQueries.map(({ key, data }) => ({
+          key,
+          data: JSON.parse(JSON.stringify(data))
+        })),
+        pending: pendingKeys
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+async function ssrStreamNavQueries(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  const navTimeout = options?.navSsrTimeout ?? 5000;
+  ensureDomShim();
+  const ctx = createRequestContext(normalizedUrl);
+  const queries = await ssrStorage.run(ctx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      createApp();
+      const discovered = getSSRQueries();
+      return discovered.map((q) => ({
+        promise: q.promise,
+        timeout: q.timeout || ssrTimeout,
+        resolve: q.resolve,
+        key: q.key
+      }));
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+  if (queries.length === 0) {
+    const encoder3 = new TextEncoder;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder3.encode(`event: done
+data: {}
+
+`));
+        controller.close();
+      }
+    });
+  }
+  const encoder2 = new TextEncoder;
+  let remaining = queries.length;
+  return new ReadableStream({
+    start(controller) {
+      let closed = false;
+      function safeEnqueue(chunk) {
+        if (closed)
+          return;
+        try {
+          controller.enqueue(chunk);
+        } catch {
+          closed = true;
+        }
+      }
+      function safeClose() {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          controller.close();
+        } catch {}
+      }
+      function checkDone() {
+        if (remaining === 0) {
+          safeEnqueue(encoder2.encode(`event: done
+data: {}
+
+`));
+          safeClose();
+        }
+      }
+      for (const { promise, resolve, key } of queries) {
+        let settled = false;
+        promise.then((data) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve(data);
+          const entry = { key, data };
+          safeEnqueue(encoder2.encode(`event: data
+data: ${safeSerialize(entry)}
+
+`));
+          remaining--;
+          checkDone();
+        }, () => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        });
+        setTimeout(() => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        }, navTimeout);
+      }
+    }
+  });
+}
+
+// src/ssr-access-evaluator.ts
+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
+  };
+}
+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-access-set.ts
+function getAccessSetForSSR(jwtPayload) {
+  if (!jwtPayload)
+    return null;
+  const acl = jwtPayload.acl;
+  if (!acl)
+    return null;
+  if (acl.overflow)
+    return null;
+  if (!acl.set)
+    return null;
+  return {
+    entitlements: Object.fromEntries(Object.entries(acl.set.entitlements).map(([name, check]) => [
+      name,
+      {
+        allowed: check.allowed,
+        reasons: check.reasons ?? [],
+        ...check.reason ? { reason: check.reason } : {},
+        ...check.meta ? { meta: check.meta } : {}
+      }
+    ])),
+    flags: acl.set.flags,
+    plan: acl.set.plan,
+    plans: acl.set.plans ?? {},
+    computedAt: acl.set.computedAt
+  };
+}
+function createAccessSetScript(accessSet, nonce) {
+  const json = JSON.stringify(accessSet);
+  const escaped = json.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  const nonceAttr = nonce ? ` nonce="${escapeAttr2(nonce)}"` : "";
+  return `<script${nonceAttr}>window.__VERTZ_ACCESS_SET__=${escaped}</script>`;
+}
+function escapeAttr2(s) {
+  return s.replace(/[&"'<>]/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+
+// 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-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;
+  ensureDomShim2();
+  const zeroDiscoveryData = attemptZeroDiscovery(normalizedUrl, module, options, ssrTimeout);
+  if (zeroDiscoveryData) {
+    return renderWithPrefetchedData(module, normalizedUrl, zeroDiscoveryData, options);
+  }
+  const discoveredData = await runDiscoveryPhase(normalizedUrl, ssrTimeout, module, options);
+  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 = resolveAppFactory2(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileThemeCached(module.theme, 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 = collectCSS2(themeCss, module);
+      const ssrData = discoveredData.resolvedQueries.map(({ key, data }) => ({
+        key,
+        data
+      }));
+      return {
+        html,
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        discoveredRoutes: renderCtx.discoveredRoutes,
+        matchedRoutePatterns: renderCtx.matchedRoutePatterns
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+async function ssrRenderProgressive(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  ensureDomShim2();
+  const discoveryResult = await runDiscoveryPhase(normalizedUrl, ssrTimeout, module, options);
+  if ("redirect" in discoveryResult) {
+    return {
+      css: "",
+      ssrData: [],
+      headTags: "",
+      redirect: discoveryResult.redirect
+    };
+  }
+  const renderCtx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    renderCtx.ssrAuth = options.ssrAuth;
+  }
+  for (const { key, data } of discoveryResult.resolvedQueries) {
+    renderCtx.queryCache.set(key, data);
+  }
+  renderCtx.resolvedComponents = discoveryResult.resolvedComponents ?? new Map;
+  return ssrStorage.run(renderCtx, () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory2(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileThemeCached(module.theme, 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 renderStream = renderToStream(vnode);
+      const css = collectCSS2(themeCss, module);
+      const ssrData = discoveryResult.resolvedQueries.map(({ key, data }) => ({
+        key,
+        data
+      }));
+      return {
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        matchedRoutePatterns: renderCtx.matchedRoutePatterns,
+        renderStream
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+async function runDiscoveryPhase(normalizedUrl, ssrTimeout, module, options) {
+  const discoveryCtx = createRequestContext(normalizedUrl);
+  if (options?.ssrAuth) {
+    discoveryCtx.ssrAuth = options.ssrAuth;
+  }
+  return ssrStorage.run(discoveryCtx, async () => {
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory2(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();
+    }
+  });
+}
+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 = resolveAppFactory2(module);
+      let themeCss = "";
+      let themePreloadTags = "";
+      if (module.theme) {
+        try {
+          const compiled = compileThemeCached(module.theme, 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 = collectCSS2(themeCss, module);
+      const ssrData = data.resolvedQueries.map(({ key, data: d }) => ({
+        key,
+        data: d
+      }));
+      return {
+        html,
+        css,
+        ssrData,
+        headTags: themePreloadTags,
+        discoveredRoutes: renderCtx.discoveredRoutes,
+        matchedRoutePatterns: renderCtx.matchedRoutePatterns
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+    }
+  });
+}
+var domShimInstalled2 = false;
+function ensureDomShim2() {
+  if (domShimInstalled2 && typeof document !== "undefined")
+    return;
+  domShimInstalled2 = true;
+  installDomShim();
+}
+function resolveAppFactory2(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 collectCSS2(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-session.ts
+function createSessionScript(session, nonce) {
+  const json = JSON.stringify(session);
+  const escaped = json.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  const nonceAttr = nonce ? ` nonce="${escapeAttr3(nonce)}"` : "";
+  return `<script${nonceAttr}>window.__VERTZ_SESSION__=${escaped}</script>`;
+}
+function escapeAttr3(s) {
+  return s.replace(/[&"'<>]/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+
+// src/template-inject.ts
+function injectIntoTemplate(options) {
+  const { template, appHtml, appCss, ssrData, nonce, headTags, sessionScript } = options;
+  let html;
+  if (template.includes("<!--ssr-outlet-->")) {
+    html = template.replace("<!--ssr-outlet-->", appHtml);
+  } else {
+    html = replaceAppDivContent(template, appHtml);
+  }
+  if (headTags) {
+    html = html.replace("</head>", `${headTags}
+</head>`);
+  }
+  if (appCss) {
+    html = html.replace(/<link\s+rel="stylesheet"\s+href="([^"]+)"[^>]*>/g, (match, href) => `<link rel="stylesheet" href="${href}" media="print" onload="this.media='all'">
+    <noscript>${match}</noscript>`);
+    html = html.replace("</head>", `${appCss}
+</head>`);
+  }
+  if (sessionScript) {
+    html = html.replace("</body>", `${sessionScript}
+</body>`);
+  }
+  if (ssrData.length > 0) {
+    const nonceAttr = nonce != null ? ` nonce="${nonce}"` : "";
+    const ssrDataScript = `<script${nonceAttr}>window.__VERTZ_SSR_DATA__=${safeSerialize(ssrData)};</script>`;
+    html = html.replace("</body>", `${ssrDataScript}
+</body>`);
+  }
+  return html;
+}
+function replaceAppDivContent(template, appHtml) {
+  const openMatch = template.match(/<div[^>]*id="app"[^>]*>/);
+  if (!openMatch || openMatch.index == null)
+    return template;
+  const openTag = openMatch[0];
+  const contentStart = openMatch.index + openTag.length;
+  let depth = 1;
+  let i = contentStart;
+  const len = template.length;
+  while (i < len && depth > 0) {
+    if (template[i] === "<") {
+      if (template.startsWith("</div>", i)) {
+        depth--;
+        if (depth === 0)
+          break;
+        i += 6;
+      } else if (template.startsWith("<div", i) && /^<div[\s>]/.test(template.slice(i, i + 5))) {
+        depth++;
+        i += 4;
+      } else {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  if (depth !== 0) {
+    return template;
+  }
+  return template.slice(0, contentStart) + appHtml + template.slice(i);
+}
+
+// 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/template-split.ts
+function splitTemplate(template, options) {
+  let processed = template;
+  if (options?.inlineCSS) {
+    processed = inlineCSSAssets(processed, options.inlineCSS);
+  }
+  const outletMarker = "<!--ssr-outlet-->";
+  const outletIndex = processed.indexOf(outletMarker);
+  if (outletIndex !== -1) {
+    return {
+      headTemplate: processed.slice(0, outletIndex),
+      tailTemplate: processed.slice(outletIndex + outletMarker.length)
+    };
+  }
+  const appDivMatch = processed.match(/<div[^>]*id="app"[^>]*>/);
+  if (appDivMatch && appDivMatch.index != null) {
+    const openTag = appDivMatch[0];
+    const contentStart = appDivMatch.index + openTag.length;
+    const closingIndex = findMatchingDivClose(processed, contentStart);
+    return {
+      headTemplate: processed.slice(0, contentStart),
+      tailTemplate: processed.slice(closingIndex)
+    };
+  }
+  throw new Error('Could not find <!--ssr-outlet--> or <div id="app"> in the HTML template. ' + "The template must contain one of these markers for SSR content injection.");
+}
+function findMatchingDivClose(html, startAfterOpen) {
+  let depth = 1;
+  let i = startAfterOpen;
+  const len = html.length;
+  while (i < len && depth > 0) {
+    if (html[i] === "<") {
+      if (html.startsWith("</div>", i)) {
+        depth--;
+        if (depth === 0)
+          return i;
+        i += 6;
+      } else if (html.startsWith("<div", i) && /^<div[\s>]/.test(html.slice(i, i + 5))) {
+        depth++;
+        i += 4;
+      } else {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return len;
+}
+function inlineCSSAssets(html, inlineCSS) {
+  let result = html;
+  for (const [href, css] of Object.entries(inlineCSS)) {
+    const escapedHref = href.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const linkPattern = new RegExp(`<link[^>]*href=["']${escapedHref}["'][^>]*>`);
+    const safeCss = css.replace(/<\//g, "<\\/");
+    result = result.replace(linkPattern, `<style data-vertz-css>${safeCss}</style>`);
+  }
+  result = result.replace(/<link\s+rel="stylesheet"\s+href="([^"]+)"[^>]*>/g, (match, href) => `<link rel="stylesheet" href="${href}" media="print" onload="this.media='all'">
+    <noscript>${match}</noscript>`);
+  return result;
+}
+
+// src/ssr-handler.ts
+function sanitizeLinkHref(href) {
+  return href.replace(/[<>,;\s"']/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function sanitizeLinkParam(value) {
+  return value.replace(/[^a-zA-Z0-9/_.-]/g, "");
+}
+function buildLinkHeader(items) {
+  return items.map((item) => {
+    const parts = [
+      `<${sanitizeLinkHref(item.href)}>`,
+      "rel=preload",
+      `as=${sanitizeLinkParam(item.as)}`
+    ];
+    if (item.type)
+      parts.push(`type=${sanitizeLinkParam(item.type)}`);
+    if (item.crossorigin)
+      parts.push("crossorigin");
+    return parts.join("; ");
+  }).join(", ");
+}
+function buildModulepreloadTags(paths) {
+  return paths.map((p) => `<link rel="modulepreload" href="${escapeAttr(p)}">`).join(`
+`);
+}
+function resolveRouteModulepreload(routeChunkManifest, matchedPatterns, fallback) {
+  if (routeChunkManifest && matchedPatterns?.length) {
+    const chunkPaths = new Set;
+    for (const pattern of matchedPatterns) {
+      const chunks = routeChunkManifest.routes[pattern];
+      if (chunks) {
+        for (const chunk of chunks) {
+          chunkPaths.add(chunk);
+        }
+      }
+    }
+    if (chunkPaths.size > 0) {
+      return buildModulepreloadTags([...chunkPaths]);
+    }
+  }
+  return fallback;
+}
+function createSSRHandler(options) {
+  const {
+    module,
+    ssrTimeout,
+    inlineCSS,
+    nonce,
+    fallbackMetrics,
+    modulepreload,
+    routeChunkManifest,
+    cacheControl,
+    sessionResolver,
+    manifest,
+    progressiveHTML
+  } = options;
+  let template = options.template;
+  if (inlineCSS) {
+    for (const [href, css] of Object.entries(inlineCSS)) {
+      const escapedHref = href.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const linkPattern = new RegExp(`<link[^>]*href=["']${escapedHref}["'][^>]*>`);
+      const safeCss = css.replace(/<\//g, "<\\/");
+      template = template.replace(linkPattern, `<style data-vertz-css>${safeCss}</style>`);
+    }
+  }
+  let linkHeader;
+  if (module.theme) {
+    const compiled = compileThemeCached(module.theme, fallbackMetrics);
+    if (compiled.preloadItems.length > 0) {
+      linkHeader = buildLinkHeader(compiled.preloadItems);
+    }
+  }
+  const modulepreloadTags = modulepreload?.length ? buildModulepreloadTags(modulepreload) : undefined;
+  const splitResult = progressiveHTML ? splitTemplate(template) : undefined;
+  if (splitResult && module.theme) {
+    splitResult.headTemplate = splitResult.headTemplate.replace(/<link\s+rel="stylesheet"\s+href="([^"]+)"[^>]*>/g, (match, href) => `<link rel="stylesheet" href="${href}" media="print" onload="this.media='all'">
+    <noscript>${match}</noscript>`);
+  }
+  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) {
+      try {
+        const sessionResult = await sessionResolver(request);
+        if (sessionResult) {
+          ssrAuth = {
+            status: "authenticated",
+            user: sessionResult.session.user,
+            expiresAt: sessionResult.session.expiresAt
+          };
+          const scripts = [];
+          scripts.push(createSessionScript(sessionResult.session, nonce));
+          if (sessionResult.accessSet != null) {
+            scripts.push(createAccessSetScript(sessionResult.accessSet, nonce));
+          }
+          sessionScript = scripts.join(`
+`);
+        } else {
+          ssrAuth = { status: "unauthenticated" };
+        }
+      } catch (resolverErr) {
+        console.warn("[Server] Session resolver failed:", resolverErr instanceof Error ? resolverErr.message : resolverErr);
+      }
+    }
+    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);
+  };
+}
+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) {
+  try {
+    const result = await ssrRenderSinglePass(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);
+    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 { escapeHtml, escapeAttr, serializeToHtml, resetSlotCounter, createSlotPlaceholder, encodeChunk, streamToString, collectStreamChunks, createTemplateChunk, renderToStream, safeSerialize, getStreamingRuntimeScript, createSSRDataChunk, compileThemeCached, createRequestContext, ssrRenderToString, ssrDiscoverQueries, toPrefetchSession, evaluateAccessRule, getAccessSetForSSR, createAccessSetScript, matchUrlToPatterns, reconstructDescriptors, ssrRenderSinglePass, createSessionScript, injectIntoTemplate, createSSRHandler };