@vertz/ui-server 0.2.38 → 0.2.41

package/dist/bun-dev-server.js

@@ -9,7 +9,7 @@ import {
 
 // src/bun-dev-server.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, watch as watch2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, watch as watch2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname, normalize, resolve } from "path";
 
 // src/debug-logger.ts
@@ -288,7 +288,7 @@ function runWithScopedFetch(interceptor, fn) {
 // src/font-metrics.ts
 import { access as fsAccess } from "fs/promises";
 import { readFile } from "fs/promises";
-import { join as join2 } from "path";
+import { isAbsolute, join as join2 } from "path";
 import { fromBuffer } from "@capsizecss/unpack";
 var SYSTEM_FONT_METRICS = {
   Arial: {
@@ -356,6 +356,12 @@ function getPrimarySrcPath(descriptor) {
   return null;
 }
 async function resolveFilePath(urlPath, rootDir) {
+  if (isAbsolute(urlPath)) {
+    try {
+      await fsAccess(urlPath);
+      return urlPath;
+    } catch {}
+  }
   const cleaned = urlPath.startsWith("/") ? urlPath.slice(1) : urlPath;
   const direct = join2(rootDir, cleaned);
   try {
@@ -395,6 +401,184 @@ async function extractFontMetrics(fonts, rootDir) {
   return result;
 }
 
+// src/google-fonts-resolver.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { createHash } from "crypto";
+import { join as join3, relative } from "path";
+var GOOGLE_FONTS_CSS2_URL = "https://fonts.googleapis.com/css2";
+var MODERN_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+var MIN_WOFF2_SIZE = 100;
+function buildGoogleFontsUrl(family, meta) {
+  const encodedFamily = family.replace(/ /g, "+");
+  const weightSpec = formatWeightSpec(meta.weight);
+  const hasItalic = meta.style.includes("italic");
+  let familyParam;
+  if (hasItalic && meta.style.includes("normal")) {
+    familyParam = `${encodedFamily}:ital,wght@0,${weightSpec};1,${weightSpec}`;
+  } else if (hasItalic) {
+    familyParam = `${encodedFamily}:ital,wght@1,${weightSpec}`;
+  } else {
+    familyParam = `${encodedFamily}:wght@${weightSpec}`;
+  }
+  return `${GOOGLE_FONTS_CSS2_URL}?family=${familyParam}&display=${meta.display}`;
+}
+function formatWeightSpec(weight) {
+  if (Array.isArray(weight)) {
+    return weight.join(";");
+  }
+  return String(weight);
+}
+function parseWoff2UrlsBySubset(css) {
+  const entries = [];
+  const blockRegex = /(?:\/\*\s*([\w-]+)\s*\*\/\s*)?@font-face\s*\{[^}]*url\(([^)]+\.woff2)\)[^}]*\}/g;
+  let match;
+  while ((match = blockRegex.exec(css)) !== null) {
+    entries.push({
+      subset: match[1] ?? "unknown",
+      url: match[2]
+    });
+  }
+  return entries;
+}
+function selectSubsetUrl(entries, requestedSubsets) {
+  for (const subset of requestedSubsets) {
+    const entry = entries.find((e) => e.subset === subset);
+    if (entry)
+      return entry.url;
+  }
+  const latin = entries.find((e) => e.subset === "latin");
+  if (latin)
+    return latin.url;
+  return entries[0].url;
+}
+function computeOptionsHash(meta) {
+  const data = JSON.stringify({
+    family: meta.family,
+    weight: meta.weight,
+    style: meta.style,
+    subsets: meta.subsets,
+    display: meta.display
+  });
+  return createHash("sha256").update(data).digest("hex").slice(0, 12);
+}
+function readManifest(cacheDir) {
+  const manifestPath = join3(cacheDir, "manifest.json");
+  if (existsSync(manifestPath)) {
+    try {
+      return JSON.parse(readFileSync(manifestPath, "utf-8"));
+    } catch {
+      return { entries: {} };
+    }
+  }
+  return { entries: {} };
+}
+function writeManifest(cacheDir, manifest) {
+  const manifestPath = join3(cacheDir, "manifest.json");
+  writeFileSync2(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function isCacheValid(cacheDir, entry) {
+  for (let i = 0;i < entry.files.length; i++) {
+    const filePath = join3(cacheDir, entry.files[i]);
+    if (!existsSync(filePath))
+      return false;
+    const stat = Bun.file(filePath).size;
+    if (stat < MIN_WOFF2_SIZE)
+      return false;
+  }
+  return true;
+}
+async function downloadFile(url, destPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  const tmpPath = destPath + ".tmp";
+  writeFileSync2(tmpPath, Buffer.from(buffer));
+  renameSync(tmpPath, destPath);
+  return buffer.byteLength;
+}
+async function resolveGoogleFonts(fonts, cacheDir, projectRoot) {
+  mkdirSync(cacheDir, { recursive: true });
+  const manifest = readManifest(cacheDir);
+  const result = {};
+  const googleEntries = [];
+  for (const [key, descriptor] of Object.entries(fonts)) {
+    if (descriptor.__google) {
+      googleEntries.push({ key, descriptor });
+    } else {
+      result[key] = descriptor;
+    }
+  }
+  await Promise.all(googleEntries.map(async ({ key, descriptor }) => {
+    const meta = descriptor.__google;
+    const hash = computeOptionsHash(meta);
+    const cached = manifest.entries[hash];
+    if (cached && isCacheValid(cacheDir, cached)) {
+      const srcPath = toSrcPath(cacheDir, cached.files[0], projectRoot);
+      result[key] = createResolvedDescriptor(descriptor, srcPath);
+      return;
+    }
+    try {
+      const url = buildGoogleFontsUrl(meta.family, meta);
+      const response = await fetch(url, {
+        headers: { "User-Agent": MODERN_USER_AGENT }
+      });
+      if (!response.ok) {
+        console.error(`[vertz] Error: Google Fonts returned ${response.status} for family "${meta.family}".` + `
+        Check https://fonts.google.com for the correct name.`);
+        result[key] = descriptor;
+        return;
+      }
+      const css = await response.text();
+      const subsetEntries = parseWoff2UrlsBySubset(css);
+      if (subsetEntries.length === 0) {
+        console.error(`[vertz] Error: No .woff2 URLs found in Google Fonts response for "${meta.family}".`);
+        result[key] = descriptor;
+        return;
+      }
+      const selectedUrl = selectSubsetUrl(subsetEntries, meta.subsets);
+      const familySlug = meta.family.toLowerCase().replace(/\s+/g, "-");
+      const fileName = `${familySlug}-${hash}.woff2`;
+      const destPath = join3(cacheDir, fileName);
+      const size = await downloadFile(selectedUrl, destPath);
+      manifest.entries[hash] = { hash, files: [fileName], sizes: [size] };
+      const totalKB = Math.round(size / 1024);
+      console.log(`[vertz] Fetching Google Font: ${meta.family}... done (1 file, ${totalKB}KB)`);
+      const srcPath = toSrcPath(cacheDir, fileName, projectRoot);
+      result[key] = createResolvedDescriptor(descriptor, srcPath);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[vertz] Error resolving Google Font "${meta.family}": ${msg}`);
+      result[key] = descriptor;
+    }
+  }));
+  writeManifest(cacheDir, manifest);
+  return result;
+}
+function toSrcPath(cacheDir, fileName, projectRoot) {
+  const absPath = join3(cacheDir, fileName);
+  if (projectRoot) {
+    return "/" + relative(projectRoot, absPath);
+  }
+  return absPath;
+}
+function createResolvedDescriptor(original, srcPath) {
+  return {
+    __brand: "FontDescriptor",
+    family: original.family,
+    weight: original.weight,
+    style: original.style,
+    display: original.display,
+    src: srcPath,
+    fallback: original.fallback,
+    subsets: original.subsets,
+    unicodeRange: original.unicodeRange,
+    adjustFontFallback: original.adjustFontFallback,
+    __google: original.__google
+  };
+}
+
 // src/ready-gate.ts
 function createReadyGate(options) {
   let ready = false;
@@ -448,7 +632,7 @@ function createReadyGate(options) {
 }
 
 // src/source-map-resolver.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve as resolvePath } from "path";
 import { originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
 function extractInlineSourceMap(jsContent) {
@@ -475,7 +659,7 @@ function resolvePosition(sourceMapJSON, line, column) {
 }
 function readLineText(filePath, line) {
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     const lines = content.split(`
 `);
     const idx = line - 1;
@@ -948,6 +1132,91 @@ function createPrefetchManifestManager(options) {
 import { compileTheme } from "@vertz/ui";
 import { EntityStore, MemoryCache, QueryEnvelopeStore } from "@vertz/ui/internals";
 
+// src/css-filter.ts
+function extractClassNamesFromHTML(html) {
+  const classes = new Set;
+  const attrRegex = /\bclass(?:Name)?="([^"]*)"/g;
+  let match;
+  while ((match = attrRegex.exec(html)) !== null) {
+    const value = match[1];
+    for (const cls of value.split(/\s+/)) {
+      if (cls)
+        classes.add(cls);
+    }
+  }
+  return classes;
+}
+function extractClassSelectorsFromCSS(css) {
+  const selectors = new Set;
+  const selectorRegex = /\.([\w-]+)/g;
+  let match;
+  while ((match = selectorRegex.exec(css)) !== null) {
+    selectors.add(match[1]);
+  }
+  return selectors;
+}
+function isKeyframesBlock(css) {
+  return /^\s*@keyframes\s/.test(css);
+}
+function hasOnlyClassSelectors(css) {
+  let stripped = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  stripped = stripped.replace(/@keyframes\s+[\w-]+\s*\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g, "");
+  stripped = stripped.replace(/@[\w-]+\s*\([^)]*\)\s*\{/g, "").replace(/^\s*\}/gm, "");
+  const ruleRegex = /([^{}]+)\{/g;
+  let match;
+  let foundAnySelector = false;
+  while ((match = ruleRegex.exec(stripped)) !== null) {
+    const selector = match[1].trim();
+    if (!selector)
+      continue;
+    foundAnySelector = true;
+    if (!selector.startsWith(".")) {
+      return false;
+    }
+  }
+  return foundAnySelector;
+}
+function filterCSSByHTML(html, cssStrings) {
+  if (cssStrings.length === 0 || !html)
+    return [];
+  const htmlClasses = extractClassNamesFromHTML(html);
+  const kept = [];
+  const pendingKeyframes = [];
+  for (const css of cssStrings) {
+    if (isKeyframesBlock(css)) {
+      const nameMatch = /@keyframes\s+([\w-]+)/.exec(css);
+      if (nameMatch) {
+        pendingKeyframes.push({ css, name: nameMatch[1] });
+      }
+      continue;
+    }
+    if (!hasOnlyClassSelectors(css)) {
+      kept.push(css);
+      continue;
+    }
+    const cssClasses = extractClassSelectorsFromCSS(css);
+    let used = false;
+    for (const cls of cssClasses) {
+      if (htmlClasses.has(cls)) {
+        used = true;
+        break;
+      }
+    }
+    if (used)
+      kept.push(css);
+  }
+  if (pendingKeyframes.length > 0) {
+    const survivingCss = kept.join(`
+`);
+    for (const kf of pendingKeyframes) {
+      if (survivingCss.includes(kf.name)) {
+        kept.push(kf.css);
+      }
+    }
+  }
+  return kept;
+}
+
 // src/dom-shim/index.ts
 import { setAdapter } from "@vertz/ui/internals";
 
@@ -1791,12 +2060,14 @@ function safeSerialize(data) {
 
 // src/ssr-render.ts
 var compiledThemeCache = new WeakMap;
+var compiledThemeWithMetricsCache = new WeakMap;
 function compileThemeCached(theme, fallbackMetrics) {
-  const cached = compiledThemeCache.get(theme);
+  const cache = fallbackMetrics ? compiledThemeWithMetricsCache : compiledThemeCache;
+  const cached = cache.get(theme);
   if (cached)
     return cached;
   const compiled = compileTheme(theme, { fallbackMetrics });
-  compiledThemeCache.set(theme, compiled);
+  cache.set(theme, compiled);
   return compiled;
 }
 function createRequestContext(url) {
@@ -1832,7 +2103,7 @@ function resolveAppFactory(module) {
   }
   return createApp;
 }
-function collectCSS(themeCss, module) {
+function collectCSS(themeCss, module, renderedHtml) {
   const alreadyIncluded = new Set;
   if (themeCss)
     alreadyIncluded.add(themeCss);
@@ -1841,8 +2112,13 @@ function collectCSS(themeCss, module) {
       alreadyIncluded.add(s);
   }
   const ssrCtx = ssrStorage.getStore();
-  const rawComponentCss = ssrCtx?.cssTracker?.size ? Array.from(ssrCtx.cssTracker) : module.getInjectedCSS?.() ?? [];
-  const componentCss = rawComponentCss.filter((s) => !alreadyIncluded.has(s));
+  const tracker = ssrCtx?.cssTracker;
+  const useTracker = tracker && tracker.size > 0;
+  const rawComponentCss = useTracker ? Array.from(tracker) : module.getInjectedCSS?.() ?? [];
+  let componentCss = rawComponentCss.filter((s) => !alreadyIncluded.has(s));
+  if (!useTracker && componentCss.length > 0 && renderedHtml) {
+    componentCss = filterCSSByHTML(renderedHtml, componentCss);
+  }
   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>` : "";
@@ -1923,7 +2199,7 @@ async function ssrRenderToString(module, url, options) {
       const vnode = toVNode(app);
       const stream = renderToStream(vnode);
       const html = await streamToString(stream);
-      const css = collectCSS(themeCss, module);
+      const css = collectCSS(themeCss, module, html);
       const ssrData = resolvedQueries.length > 0 ? resolvedQueries.map(({ key, data }) => ({ key, data })) : [];
       return {
         html,
@@ -2226,7 +2502,7 @@ async function ssrRenderSinglePass(module, url, options) {
       const vnode = toVNode(app);
       const stream = renderToStream(vnode);
       const html = await streamToString(stream);
-      const css = collectCSS2(themeCss, module);
+      const css = collectCSS2(themeCss, module, html);
       const ssrData = discoveredData.resolvedQueries.map(({ key, data }) => ({
         key,
         data
@@ -2378,7 +2654,7 @@ async function renderWithPrefetchedData(module, normalizedUrl, prefetchedData, o
           matchedRoutePatterns: renderCtx.matchedRoutePatterns
         };
       }
-      const css = collectCSS2(themeCss, module);
+      const css = collectCSS2(themeCss, module, html);
       const ssrData = data.resolvedQueries.map(({ key, data: d }) => ({
         key,
         data: d
@@ -2451,7 +2727,7 @@ function extractMethodFromKey(key) {
   const segments = cleanPath.split("/").filter(Boolean);
   return segments.length > 1 ? "get" : "list";
 }
-function collectCSS2(themeCss, module) {
+function collectCSS2(themeCss, module, renderedHtml) {
   const alreadyIncluded = new Set;
   if (themeCss)
     alreadyIncluded.add(themeCss);
@@ -2460,8 +2736,13 @@ function collectCSS2(themeCss, module) {
       alreadyIncluded.add(s);
   }
   const ssrCtx = ssrStorage.getStore();
-  const rawComponentCss = ssrCtx?.cssTracker?.size ? Array.from(ssrCtx.cssTracker) : module.getInjectedCSS?.() ?? [];
-  const componentCss = rawComponentCss.filter((s) => !alreadyIncluded.has(s));
+  const tracker = ssrCtx?.cssTracker;
+  const useTracker = tracker && tracker.size > 0;
+  const rawComponentCss = useTracker ? Array.from(tracker) : module.getInjectedCSS?.() ?? [];
+  let componentCss = rawComponentCss.filter((s) => !alreadyIncluded.has(s));
+  if (!useTracker && componentCss.length > 0 && renderedHtml) {
+    componentCss = filterCSSByHTML(renderedHtml, componentCss);
+  }
   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>` : "";
@@ -2472,21 +2753,21 @@ function collectCSS2(themeCss, module) {
 }
 
 // src/upstream-watcher.ts
-import { existsSync, lstatSync, readdirSync, realpathSync, watch } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, lstatSync, readdirSync, realpathSync, watch } from "fs";
+import { join as join4 } from "path";
 function resolveWorkspacePackages(projectRoot, filter) {
   const results = [];
   const packageNames = filter === true ? discoverVertzPackages(projectRoot) : parsePackageNames(filter);
   for (const { scope, name } of packageNames) {
-    const nmPath = join3(projectRoot, "node_modules", scope, name);
-    if (!existsSync(nmPath))
+    const nmPath = join4(projectRoot, "node_modules", scope, name);
+    if (!existsSync2(nmPath))
       continue;
     const stat = lstatSync(nmPath);
     if (!stat.isSymbolicLink())
       continue;
     const realPath = realpathSync(nmPath);
-    const distPath = join3(realPath, "dist");
-    if (!existsSync(distPath))
+    const distPath = join4(realPath, "dist");
+    if (!existsSync2(distPath))
       continue;
     const fullName = scope ? `${scope}/${name}` : name;
     results.push({ name: fullName, distPath });
@@ -2494,8 +2775,8 @@ function resolveWorkspacePackages(projectRoot, filter) {
   return results;
 }
 function discoverVertzPackages(projectRoot) {
-  const scopeDir = join3(projectRoot, "node_modules", "@vertz");
-  if (!existsSync(scopeDir))
+  const scopeDir = join4(projectRoot, "node_modules", "@vertz");
+  if (!existsSync2(scopeDir))
     return [];
   return readdirSync(scopeDir).filter((entry) => !entry.startsWith(".")).map((entry) => ({ scope: "@vertz", name: entry }));
 }
@@ -2553,7 +2834,7 @@ function createUpstreamWatcher(options) {
 // src/bun-dev-server.ts
 function detectFaviconTag(projectRoot) {
   const faviconPath = resolve(projectRoot, "public", "favicon.svg");
-  return existsSync2(faviconPath) ? '<link rel="icon" type="image/svg+xml" href="/favicon.svg">' : "";
+  return existsSync3(faviconPath) ? '<link rel="icon" type="image/svg+xml" href="/favicon.svg">' : "";
 }
 var STALE_GRAPH_PATTERNS = [
   /Export named ['"].*['"] not found in module/i,
@@ -2982,7 +3263,7 @@ function createBunDevServer(options) {
     installFetchProxy();
   }
   const devDir = resolve(projectRoot, ".vertz", "dev");
-  mkdirSync(devDir, { recursive: true });
+  mkdirSync2(devDir, { recursive: true });
   const logger = createDebugLogger(devDir);
   const diagnostics = new DiagnosticsCollector;
   let aotManifestManager = null;
@@ -3206,7 +3487,7 @@ function createBunDevServer(options) {
     if (!openapi)
       return null;
     try {
-      const specContent = readFileSync2(openapi.specPath, "utf-8");
+      const specContent = readFileSync3(openapi.specPath, "utf-8");
       return JSON.parse(specContent);
     } catch (err) {
       console.error("[Server] Error reading OpenAPI spec:", err);
@@ -3214,7 +3495,7 @@ function createBunDevServer(options) {
     }
   };
   const setupOpenAPIWatcher = () => {
-    if (!openapi || !existsSync2(openapi.specPath))
+    if (!openapi || !existsSync3(openapi.specPath))
       return;
     cachedSpec = loadOpenAPISpec();
     if (cachedSpec === null)
@@ -3240,7 +3521,7 @@ function createBunDevServer(options) {
         headers: { "Content-Type": "application/json" }
       });
     }
-    if (openapi && existsSync2(openapi.specPath)) {
+    if (openapi && existsSync3(openapi.specPath)) {
       cachedSpec = loadOpenAPISpec();
       if (cachedSpec) {
         return new Response(JSON.stringify(cachedSpec), {
@@ -3330,10 +3611,10 @@ function createBunDevServer(options) {
     let ssrMod;
     try {
       if (isRestarting) {
-        mkdirSync(devDir, { recursive: true });
+        mkdirSync2(devDir, { recursive: true });
         const ssrBootPath = resolve(devDir, "ssr-reload-entry.ts");
         const ts = Date.now();
-        writeFileSync2(ssrBootPath, `export * from '${entryPath}';
+        writeFileSync3(ssrBootPath, `export * from '${entryPath}';
 `);
         ssrMod = await import(`${ssrBootPath}?t=${ts}`);
       } else {
@@ -3358,6 +3639,18 @@ function createBunDevServer(options) {
         process.exit(1);
       }
     }
+    const fontCacheDir = resolve(projectRoot, ".vertz", "fonts");
+    if (ssrMod.theme?.fonts) {
+      try {
+        const resolvedFonts = await resolveGoogleFonts(ssrMod.theme.fonts, fontCacheDir, projectRoot);
+        ssrMod = {
+          ...ssrMod,
+          theme: { ...ssrMod.theme, fonts: resolvedFonts }
+        };
+      } catch (e) {
+        console.warn("[Server] Failed to resolve Google Fonts:", e);
+      }
+    }
     let fontFallbackMetrics;
     if (ssrMod.theme?.fonts) {
       try {
@@ -3369,13 +3662,13 @@ function createBunDevServer(options) {
     let prefetchManager = null;
     const srcDir = resolve(projectRoot, "src");
     const routerCandidates = [resolve(srcDir, "router.tsx"), resolve(srcDir, "router.ts")];
-    const routerPath = routerCandidates.find((p) => existsSync2(p));
+    const routerPath = routerCandidates.find((p) => existsSync3(p));
     if (routerPath) {
       prefetchManager = createPrefetchManifestManager({
         routerPath,
         readFile: (path) => {
           try {
-            return readFileSync2(path, "utf-8");
+            return readFileSync3(path, "utf-8");
           } catch {
             return;
           }
@@ -3387,12 +3680,12 @@ function createBunDevServer(options) {
           const base = resolve(dir, specifier);
           for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
             const candidate = `${base}${ext}`;
-            if (existsSync2(candidate))
+            if (existsSync3(candidate))
               return candidate;
           }
           for (const ext of [".tsx", ".ts"]) {
             const candidate = resolve(base, `index${ext}`);
-            if (existsSync2(candidate))
+            if (existsSync3(candidate))
               return candidate;
           }
           return;
@@ -3416,7 +3709,7 @@ function createBunDevServer(options) {
     aotManifestManager = createAotManifestManager({
       readFile: (path) => {
         try {
-          return readFileSync2(path, "utf-8");
+          return readFileSync3(path, "utf-8");
         } catch {
           return;
         }
@@ -3443,9 +3736,9 @@ function createBunDevServer(options) {
       console.warn("[Server] Failed to build AOT manifest:", e instanceof Error ? e.message : e);
       aotManifestManager = null;
     }
-    mkdirSync(devDir, { recursive: true });
+    mkdirSync2(devDir, { recursive: true });
     const frInitPath = resolve(devDir, "fast-refresh-init.ts");
-    writeFileSync2(frInitPath, `import '@vertz/ui-server/fast-refresh-runtime';
+    writeFileSync3(frInitPath, `import '@vertz/ui-server/fast-refresh-runtime';
 if (import.meta.hot) import.meta.hot.accept();
 `);
     const hmrShellHtml = `<!doctype html>
@@ -3457,7 +3750,7 @@ if (import.meta.hot) import.meta.hot.accept();
   <script type="module" src="${clientSrc}"></script>
 </body></html>`;
     const hmrShellPath = resolve(devDir, "hmr-shell.html");
-    writeFileSync2(hmrShellPath, hmrShellHtml);
+    writeFileSync3(hmrShellPath, hmrShellHtml);
     const hmrShellModule = __require(hmrShellPath);
     setupOpenAPIWatcher();
     let bundledScriptUrl = null;
@@ -3924,7 +4217,7 @@ data: {}
       return false;
     }
     stopped = false;
-    if (existsSync2(srcDir)) {
+    if (existsSync3(srcDir)) {
       srcWatcherRef = watch2(srcDir, { recursive: true }, (_event, filename) => {
         if (!filename)
           return;
@@ -4058,12 +4351,21 @@ data: {}
           const cacheCleared = clearSSRRequireCache();
           logger.log("watcher", "cache-cleared", { entries: cacheCleared });
           const ssrWrapperPath = resolve(devDir, "ssr-reload-entry.ts");
-          mkdirSync(devDir, { recursive: true });
-          writeFileSync2(ssrWrapperPath, `export * from '${entryPath}';
+          mkdirSync2(devDir, { recursive: true });
+          writeFileSync3(ssrWrapperPath, `export * from '${entryPath}';
 `);
           const ssrReloadStart = performance.now();
           try {
-            const freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+            let freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+            if (freshMod.theme?.fonts) {
+              try {
+                const resolvedFonts = await resolveGoogleFonts(freshMod.theme.fonts, fontCacheDir, projectRoot);
+                freshMod = {
+                  ...freshMod,
+                  theme: { ...freshMod.theme, fonts: resolvedFonts }
+                };
+              } catch {}
+            }
             ssrMod = freshMod;
             ssrFallback = false;
             if (freshMod.theme?.fonts) {
@@ -4088,11 +4390,20 @@ data: {}
             if (stopped)
               return;
             clearSSRRequireCache();
-            mkdirSync(devDir, { recursive: true });
-            writeFileSync2(ssrWrapperPath, `export * from '${entryPath}';
+            mkdirSync2(devDir, { recursive: true });
+            writeFileSync3(ssrWrapperPath, `export * from '${entryPath}';
 `);
             try {
-              const freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+              let freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+              if (freshMod.theme?.fonts) {
+                try {
+                  const resolvedFonts = await resolveGoogleFonts(freshMod.theme.fonts, fontCacheDir, projectRoot);
+                  freshMod = {
+                    ...freshMod,
+                    theme: { ...freshMod.theme, fonts: resolvedFonts }
+                  };
+                } catch {}
+              }
               ssrMod = freshMod;
               ssrFallback = false;
               if (freshMod.theme?.fonts) {