@vertz/ui-server 0.2.25 → 0.2.28

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, readFileSync as readFileSync2, watch as watch2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, watch as watch2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname, normalize, resolve } from "path";
 
 // src/debug-logger.ts
@@ -593,14 +593,16 @@ function createSourceMapResolver(projectRoot) {
 }
 
 // src/ssr-access-evaluator.ts
-function toPrefetchSession(ssrAuth) {
+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
   };
 }
@@ -644,6 +646,186 @@ function escapeAttr(s) {
   return s.replace(/[&"'<>]/g, (c) => `&#${c.charCodeAt(0)};`);
 }
 
+// src/ssr-aot-manifest-dev.ts
+import { compileForSSRAot } from "@vertz/ui-compiler";
+
+// src/ssr-aot-diagnostics.ts
+var MAX_DIVERGENCES = 20;
+
+class AotDiagnostics {
+  _components = new Map;
+  _divergences = [];
+  recordCompilation(components) {
+    for (const comp of components) {
+      this._components.set(comp.name, {
+        tier: comp.tier,
+        holes: comp.holes
+      });
+    }
+  }
+  recordDivergence(component, aotHtml, domHtml) {
+    this._divergences.push({
+      component,
+      aotHtml,
+      domHtml,
+      timestamp: new Date().toISOString()
+    });
+    if (this._divergences.length > MAX_DIVERGENCES) {
+      this._divergences = this._divergences.slice(this._divergences.length - MAX_DIVERGENCES);
+    }
+  }
+  clear() {
+    this._components.clear();
+    this._divergences = [];
+  }
+  clearComponents() {
+    this._components.clear();
+  }
+  getClassificationLog() {
+    const lines = [];
+    for (const [name, comp] of this._components) {
+      let line = `${name}: ${comp.tier}`;
+      if (comp.holes.length > 0) {
+        line += `, ${comp.holes.length} hole${comp.holes.length > 1 ? "s" : ""} (${comp.holes.join(", ")})`;
+      }
+      lines.push(line);
+    }
+    const snapshot = this.getSnapshot();
+    const { total, aot, percentage } = snapshot.coverage;
+    if (total > 0) {
+      lines.push(`Coverage: ${aot}/${total} components (${percentage}%)`);
+    }
+    return lines;
+  }
+  getSnapshot() {
+    let aot = 0;
+    let runtime = 0;
+    for (const comp of this._components.values()) {
+      if (comp.tier === "runtime-fallback") {
+        runtime++;
+      } else {
+        aot++;
+      }
+    }
+    const total = aot + runtime;
+    return {
+      components: Object.fromEntries(this._components),
+      coverage: {
+        total,
+        aot,
+        runtime,
+        percentage: total === 0 ? 0 : Math.round(aot / total * 100)
+      },
+      divergences: [...this._divergences]
+    };
+  }
+}
+
+// src/ssr-aot-manifest-dev.ts
+function createAotManifestManager(options) {
+  const { readFile: readFile2, listFiles } = options;
+  let currentManifest = null;
+  const diagnostics = new AotDiagnostics;
+  let rebuildCount = 0;
+  let lastRebuildMs = null;
+  let lastRebuildAt = null;
+  function compileFile(filePath, source) {
+    try {
+      const result = compileForSSRAot(source, { filename: filePath });
+      return result.components.map((comp) => ({
+        name: comp.name,
+        entry: {
+          tier: comp.tier,
+          holes: comp.holes,
+          file: filePath
+        }
+      }));
+    } catch {
+      return [];
+    }
+  }
+  function updateDiagnostics(manifest, isFullBuild) {
+    if (isFullBuild) {
+      diagnostics.clear();
+    } else {
+      diagnostics.clearComponents();
+    }
+    const entries = Object.entries(manifest.components).map(([name, entry]) => ({
+      name,
+      tier: entry.tier,
+      holes: entry.holes
+    }));
+    diagnostics.recordCompilation(entries);
+  }
+  function fullBuild() {
+    const start = performance.now();
+    const files = listFiles();
+    const components = {};
+    for (const filePath of files) {
+      if (!filePath.endsWith(".tsx"))
+        continue;
+      const source = readFile2(filePath);
+      if (!source)
+        continue;
+      const entries = compileFile(filePath, source);
+      for (const { name, entry } of entries) {
+        components[name] = entry;
+      }
+    }
+    currentManifest = { components };
+    updateDiagnostics(currentManifest, true);
+    rebuildCount++;
+    lastRebuildMs = Math.round(performance.now() - start);
+    lastRebuildAt = new Date().toISOString();
+  }
+  function incrementalUpdate(filePath, sourceText) {
+    if (!currentManifest)
+      return;
+    const start = performance.now();
+    const newComponents = { ...currentManifest.components };
+    for (const [name, entry] of Object.entries(newComponents)) {
+      if (entry.file === filePath) {
+        delete newComponents[name];
+      }
+    }
+    if (sourceText.trim()) {
+      const entries = compileFile(filePath, sourceText);
+      for (const { name, entry } of entries) {
+        newComponents[name] = entry;
+      }
+    }
+    currentManifest = { components: newComponents };
+    updateDiagnostics(currentManifest, false);
+    rebuildCount++;
+    lastRebuildMs = Math.round(performance.now() - start);
+    lastRebuildAt = new Date().toISOString();
+  }
+  return {
+    build() {
+      fullBuild();
+    },
+    onFileChange(filePath, sourceText) {
+      if (!filePath.endsWith(".tsx"))
+        return;
+      incrementalUpdate(filePath, sourceText);
+    },
+    getManifest() {
+      return currentManifest;
+    },
+    getSnapshot() {
+      return {
+        manifest: currentManifest,
+        rebuildCount,
+        lastRebuildMs,
+        lastRebuildAt
+      };
+    },
+    getDiagnostics() {
+      return diagnostics;
+    }
+  };
+}
+
 // src/ssr-prefetch-dev.ts
 import {
   analyzeComponentQueries,
@@ -2726,6 +2908,18 @@ function clearSSRRequireCache() {
   }
   return keys.length;
 }
+function collectFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const fullPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
 function createBunDevServer(options) {
   const {
     entry,
@@ -2756,6 +2950,7 @@ function createBunDevServer(options) {
   mkdirSync(devDir, { recursive: true });
   const logger = createDebugLogger(devDir);
   const diagnostics = new DiagnosticsCollector;
+  let aotManifestManager = null;
   let server = null;
   let srcWatcherRef = null;
   let refreshTimeout = null;
@@ -3170,6 +3365,36 @@ function createBunDevServer(options) {
         prefetchManager = null;
       }
     }
+    aotManifestManager = createAotManifestManager({
+      readFile: (path) => {
+        try {
+          return readFileSync2(path, "utf-8");
+        } catch {
+          return;
+        }
+      },
+      listFiles: () => {
+        try {
+          return collectFiles(srcDir);
+        } catch {
+          return [];
+        }
+      }
+    });
+    try {
+      const aotStart = performance.now();
+      aotManifestManager.build();
+      const aotMs = Math.round(performance.now() - aotStart);
+      logger.log("aot", "initial-build", { durationMs: aotMs });
+      if (logRequests) {
+        const manifest = aotManifestManager.getManifest();
+        const count = manifest ? Object.keys(manifest.components).length : 0;
+        console.log(`[Server] AOT manifest built (${count} components, ${aotMs}ms)`);
+      }
+    } catch (e) {
+      console.warn("[Server] Failed to build AOT manifest:", e instanceof Error ? e.message : e);
+      aotManifestManager = null;
+    }
     mkdirSync(devDir, { recursive: true });
     const frInitPath = resolve(devDir, "fast-refresh-init.ts");
     writeFileSync2(frInitPath, `import '@vertz/ui-server/fast-refresh-runtime';
@@ -3260,6 +3485,12 @@ if (import.meta.hot) import.meta.hot.accept();
         if (pathname === "/__vertz_diagnostics") {
           return Response.json(diagnostics.getSnapshot());
         }
+        if (pathname === "/__vertz_ssr_aot") {
+          if (!aotManifestManager) {
+            return Response.json({ error: "AOT manifest manager not available" }, { status: 404 });
+          }
+          return Response.json(aotManifestManager.getDiagnostics().getSnapshot());
+        }
         if (pathname === "/__vertz_prefetch_manifest") {
           if (!prefetchManager) {
             return Response.json({ error: "No prefetch manifest available (router file not found)" }, { status: 404 });
@@ -3354,6 +3585,7 @@ data: {}
           }) : null;
           let sessionScript = "";
           let ssrAuth;
+          let ssrAccessSet;
           if (sessionResolver) {
             try {
               const sessionResult = await sessionResolver(request);
@@ -3363,6 +3595,7 @@ data: {}
                   user: sessionResult.session.user,
                   expiresAt: sessionResult.session.expiresAt
                 };
+                ssrAccessSet = sessionResult.accessSet;
                 const scripts = [];
                 scripts.push(createSessionScript(sessionResult.session));
                 if (sessionResult.accessSet != null) {
@@ -3397,7 +3630,7 @@ data: {}
               fallbackMetrics: fontFallbackMetrics,
               ssrAuth,
               manifest: prefetchManager?.getSSRManifest(),
-              prefetchSession: toPrefetchSession(ssrAuth)
+              prefetchSession: toPrefetchSession(ssrAuth, ssrAccessSet)
             });
             logger.log("ssr", "render-done", {
               url: pathname,
@@ -3687,7 +3920,20 @@ data: {}
                   isRouter: changedFilePath === routerPath
                 });
               }
-            } catch {}
+              if (aotManifestManager) {
+                const aotStart = performance.now();
+                aotManifestManager.onFileChange(changedFilePath, source);
+                const aotMs = Math.round(performance.now() - aotStart);
+                logger.log("aot", "rebuild", {
+                  file: lastChangedFile,
+                  durationMs: aotMs
+                });
+              }
+            } catch {
+              if (aotManifestManager) {
+                aotManifestManager.onFileChange(changedFilePath, "");
+              }
+            }
           }
           if (stopped)
             return;

package/dist/bun-plugin/index.d.ts

@@ -1,6 +1,6 @@
 type ErrorCategory = "build" | "resolve" | "runtime" | "ssr";
 import { CSSExtractionResult } from "@vertz/ui-compiler";
-type DebugCategory = "fields" | "manifest" | "plugin" | "prefetch" | "ssr" | "watcher" | "ws";
+type DebugCategory = "aot" | "fields" | "manifest" | "plugin" | "prefetch" | "ssr" | "watcher" | "ws";
 interface DebugLogger {
 	log(category: DebugCategory, message: string, data?: Record<string, unknown>): void;
 	isEnabled(category: DebugCategory): boolean;