@vertz/cli 0.2.15 → 0.2.17

package/dist/vertz.js

@@ -9,6 +9,8 @@ import { Command } from "commander";
 import { createJiti } from "jiti";
 
 // src/commands/build.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 import { err, ok } from "@vertz/errors";
 
 // src/dev-server/app-detector.ts
@@ -56,10 +58,7 @@ import * as esbuild from "esbuild";
 
 // src/pipeline/orchestrator.ts
 import { createCodegenPipeline, generate } from "@vertz/codegen";
-import {
-  createCompiler,
-  OpenAPIGenerator
-} from "@vertz/compiler";
+import { createCompiler, OpenAPIGenerator } from "@vertz/compiler";
 var defaultPipelineConfig = {
   sourceDir: "src",
   outputDir: ".vertz/generated",
@@ -133,6 +132,13 @@ class PipelineOrchestrator {
           success = false;
         }
       }
+      if (success) {
+        const buildUIResult = await this.runBuildUI();
+        stages.push(buildUIResult);
+        if (!buildUIResult.success) {
+          success = false;
+        }
+      }
     } catch (error) {
       success = false;
       stages.push({
@@ -274,12 +280,36 @@ class PipelineOrchestrator {
   }
   async runBuildUI() {
     const startTime = performance.now();
-    return {
-      stage: "build-ui",
-      success: true,
-      durationMs: performance.now() - startTime,
-      output: "UI build delegated to Vite"
-    };
+    try {
+      if (this.config._uiCompilerValidator) {
+        const result = await this.config._uiCompilerValidator();
+        return {
+          stage: "build-ui",
+          success: true,
+          durationMs: performance.now() - startTime,
+          output: `UI compiler validated (${result.fileCount} source files)`
+        };
+      }
+      const { createVertzBunPlugin } = await import("@vertz/ui-server/bun-plugin");
+      const pluginOptions = {
+        hmr: false,
+        fastRefresh: false
+      };
+      createVertzBunPlugin(pluginOptions);
+      return {
+        stage: "build-ui",
+        success: true,
+        durationMs: performance.now() - startTime,
+        output: "UI compiler validated"
+      };
+    } catch (error) {
+      return {
+        stage: "build-ui",
+        success: false,
+        durationMs: performance.now() - startTime,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
   }
   async runDbSync() {
     const startTime = performance.now();
@@ -791,11 +821,29 @@ class BuildOrchestrator {
   }
 }
 // src/production-build/ui-build-pipeline.ts
-import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { resolve } from "node:path";
+import {
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname, join as join3, resolve } from "node:path";
+import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
 async function buildUI(config) {
   const startTime = performance.now();
-  const { projectRoot, clientEntry, serverEntry, outputDir, minify, sourcemap, title = "Vertz App" } = config;
+  const {
+    projectRoot,
+    clientEntry,
+    serverEntry,
+    outputDir,
+    minify,
+    sourcemap,
+    title = "Vertz App",
+    description
+  } = config;
   const distDir = resolve(projectRoot, outputDir);
   const distClient = resolve(distDir, "client");
   const distServer = resolve(distDir, "server");
@@ -807,7 +855,8 @@ async function buildUI(config) {
     console.log("\uD83D\uDCE6 Building client...");
     const { plugin: clientPlugin, fileExtractions } = createVertzBunPlugin({
       hmr: false,
-      fastRefresh: false
+      fastRefresh: false,
+      routeSplitting: true
     });
     const clientResult = await Bun.build({
       entrypoints: [clientEntry],
@@ -831,15 +880,21 @@ ${errors}`,
     }
     let clientJsPath = "";
     const clientCssPaths = [];
+    const chunkPaths = [];
     for (const output of clientResult.outputs) {
       const name = output.path.replace(distClient, "");
       if (output.kind === "entry-point") {
         clientJsPath = name;
       } else if (output.path.endsWith(".css")) {
         clientCssPaths.push(name);
+      } else if (output.kind === "chunk" && output.path.endsWith(".js")) {
+        chunkPaths.push(name);
       }
     }
     console.log(`  JS entry: ${clientJsPath}`);
+    for (const chunk of chunkPaths) {
+      console.log(`  JS chunk: ${chunk}`);
+    }
     for (const css of clientCssPaths) {
       console.log(`  CSS: ${css}`);
     }
@@ -859,25 +914,44 @@ ${errors}`,
     console.log("\uD83D\uDCC4 Generating HTML...");
     const cssLinks = clientCssPaths.map((path) => `    <link rel="stylesheet" href="${path}">`).join(`
 `);
+    const modulepreloadLinks = chunkPaths.map((path) => `    <link rel="modulepreload" href="${path}">`).join(`
+`);
+    const descriptionTag = description ? `
+    <meta name="description" content="${description.replace(/"/g, "&quot;")}" />` : "";
+    const publicDir = resolve(projectRoot, "public");
+    const hasFavicon = existsSync3(resolve(publicDir, "favicon.svg"));
+    const hasManifest = existsSync3(resolve(publicDir, "site.webmanifest"));
+    const faviconTag = hasFavicon ? `
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg">` : "";
+    const manifestTag = hasManifest ? `
+    <link rel="manifest" href="/site.webmanifest">` : "";
+    const themeColorTag = `
+    <meta name="theme-color" content="#0a0a0b">`;
     const html = `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${title}</title>
+    <title>${title}</title>${descriptionTag}${themeColorTag}${faviconTag}${manifestTag}
 ${cssLinks}
+${modulepreloadLinks}
   </head>
   <body>
     <div id="app"></div>
     <script type="module" crossorigin src="${clientJsPath}"></script>
   </body>
 </html>`;
-    writeFileSync2(resolve(distClient, "index.html"), html);
-    const publicDir = resolve(projectRoot, "public");
+    writeFileSync2(resolve(distClient, "_shell.html"), html);
     if (existsSync3(publicDir)) {
       cpSync(publicDir, distClient, { recursive: true });
       console.log("  Copied public/ assets");
     }
+    const imagesDir = resolve(projectRoot, ".vertz", "images");
+    if (existsSync3(imagesDir)) {
+      const imgDest = resolve(distClient, "__vertz_img");
+      cpSync(imagesDir, imgDest, { recursive: true });
+      console.log("  Copied optimized images");
+    }
     console.log("\uD83D\uDCE6 Building server...");
     const jsxSwapPlugin = {
       name: "vertz-ssr-jsx-swap",
@@ -914,6 +988,67 @@ ${errors}`,
       };
     }
     console.log("  Server entry: dist/server/app.js");
+    console.log("\uD83D\uDCC4 Pre-rendering routes...");
+    const {
+      discoverRoutes,
+      filterPrerenderableRoutes,
+      prerenderRoutes,
+      stripScriptsFromStaticHTML
+    } = await import("@vertz/ui-server/ssr");
+    const ssrEntryPath = resolve(distServer, "app.js");
+    let ssrModule;
+    try {
+      ssrModule = await import(ssrEntryPath);
+    } catch (error) {
+      console.log("  ⚠ Could not import SSR module for pre-rendering, skipping.");
+      console.log(`    ${error instanceof Error ? error.message : String(error)}`);
+      const durationMs2 = performance.now() - startTime;
+      console.log(`
+✅ UI build complete (without pre-rendering)!`);
+      console.log(`  Client: ${distClient}/`);
+      console.log(`  Server: ${distServer}/`);
+      return { success: true, durationMs: durationMs2 };
+    }
+    let allPatterns;
+    try {
+      allPatterns = await discoverRoutes(ssrModule);
+    } catch (error) {
+      console.log("  ⚠ Route discovery failed, skipping pre-rendering.");
+      console.log(`    ${error instanceof Error ? error.message : String(error)}`);
+      const durationMs2 = performance.now() - startTime;
+      console.log(`
+✅ UI build complete (without pre-rendering)!`);
+      console.log(`  Client: ${distClient}/`);
+      console.log(`  Server: ${distServer}/`);
+      return { success: true, durationMs: durationMs2 };
+    }
+    if (allPatterns.length === 0) {
+      console.log("  No routes discovered (app may not use createRouter).");
+    } else {
+      console.log(`  Discovered ${allPatterns.length} route(s): ${allPatterns.join(", ")}`);
+      const prerenderableRoutes = filterPrerenderableRoutes(allPatterns);
+      console.log(`  Pre-rendering ${prerenderableRoutes.length} static route(s)...`);
+      if (prerenderableRoutes.length > 0) {
+        const results = await prerenderRoutes(ssrModule, html, {
+          routes: prerenderableRoutes
+        });
+        const isIslandsMode = results.some((r) => r.html.includes("data-v-island"));
+        for (const result of results) {
+          const outPath = result.path === "/" ? resolve(distClient, "index.html") : resolve(distClient, `${result.path.replace(/^\//, "")}/index.html`);
+          mkdirSync2(dirname(outPath), { recursive: true });
+          const finalHtml = isIslandsMode ? stripScriptsFromStaticHTML(result.html) : result.html;
+          const stripped = finalHtml !== result.html;
+          writeFileSync2(outPath, finalHtml);
+          const suffix = stripped ? " (static — JS stripped)" : "";
+          console.log(`  ✓ ${result.path} → ${outPath.replace(distClient, "dist/client")}${suffix}`);
+        }
+      }
+    }
+    console.log("\uD83D\uDDDC️  Pre-compressing assets with Brotli...");
+    const compressedCount = brotliCompressDir(distClient);
+    if (compressedCount > 0) {
+      console.log(`  Compressed ${compressedCount} file(s)`);
+    }
     const durationMs = performance.now() - startTime;
     console.log(`
 ✅ UI build complete!`);
@@ -928,19 +1063,52 @@ ${errors}`,
     };
   }
 }
+var COMPRESSIBLE_EXTENSIONS = new Set([".html", ".js", ".css", ".svg", ".xml", ".txt", ".json"]);
+var MIN_COMPRESS_SIZE = 256;
+function brotliCompressDir(dir) {
+  let count = 0;
+  function walk(currentDir) {
+    for (const entry of readdirSync2(currentDir, { withFileTypes: true })) {
+      const fullPath = join3(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (entry.name.endsWith(".br"))
+        continue;
+      const ext = entry.name.substring(entry.name.lastIndexOf("."));
+      if (!COMPRESSIBLE_EXTENSIONS.has(ext))
+        continue;
+      const content = readFileSync(fullPath);
+      if (content.length < MIN_COMPRESS_SIZE)
+        continue;
+      const compressed = brotliCompressSync(content, {
+        params: {
+          [zlibConstants.BROTLI_PARAM_QUALITY]: zlibConstants.BROTLI_MAX_QUALITY
+        }
+      });
+      if (compressed.length < content.length) {
+        writeFileSync2(`${fullPath}.br`, compressed);
+        count++;
+      }
+    }
+  }
+  walk(dir);
+  return count;
+}
 // src/utils/paths.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { dirname, join as join3, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
 var ROOT_MARKERS = ["package.json", "vertz.config.ts", "vertz.config.js"];
 function findProjectRoot(startDir) {
   let current = resolve2(startDir ?? process.cwd());
   while (true) {
     for (const marker of ROOT_MARKERS) {
-      if (existsSync4(join3(current, marker))) {
+      if (existsSync4(join4(current, marker))) {
         return current;
       }
     }
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current) {
       break;
     }
@@ -1076,13 +1244,23 @@ async function buildUIOnly(detected, options) {
     console.log(`  Sourcemap: ${sourcemap ? "enabled" : "disabled"}`);
     console.log("");
   }
+  let title;
+  let description;
+  try {
+    const pkgPath = resolve3(detected.projectRoot, "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    title = pkg.vertz?.title ?? pkg.title;
+    description = pkg.vertz?.description ?? pkg.description;
+  } catch {}
   const result = await buildUI({
     projectRoot: detected.projectRoot,
     clientEntry: detected.clientEntry,
     serverEntry,
     outputDir: "dist",
     minify: !noMinify,
-    sourcemap
+    sourcemap,
+    title,
+    description
   });
   if (!result.success) {
     return err(new Error(result.error));
@@ -1278,13 +1456,13 @@ async function dbBaselineAction(options) {
 }
 
 // src/commands/dev.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { err as err5, ok as ok5 } from "@vertz/errors";
 
 // src/dev-server/fullstack-server.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join4, relative } from "node:path";
+import { join as join5, relative } from "node:path";
 
 // src/dev-server/process-manager.ts
 function createProcessManager(spawnFn) {
@@ -1321,14 +1499,14 @@ function createProcessManager(spawnFn) {
         return;
       const proc = child;
       child = undefined;
-      await new Promise((resolve3) => {
+      await new Promise((resolve4) => {
         const timeout = setTimeout(() => {
           proc.kill("SIGKILL");
-          resolve3();
+          resolve4();
         }, 2000);
         proc.on("exit", () => {
           clearTimeout(timeout);
-          resolve3();
+          resolve4();
         });
         proc.kill("SIGTERM");
       });
@@ -1397,7 +1575,11 @@ Expected: export default createServer({ ... })`);
     throw new Error(`${serverEntry} default export must have a .handler function.
 Expected: export default createServer({ ... })`);
   }
-  return mod;
+  let sessionResolver;
+  if ("auth" in mod && mod.auth && typeof mod.auth.resolveSessionForSSR === "function") {
+    sessionResolver = mod.auth.resolveSessionForSSR;
+  }
+  return { ...mod, sessionResolver };
 }
 function formatBanner(appType, port, host) {
   const url = `http://${host}:${port}`;
@@ -1418,19 +1600,22 @@ async function startDevServer(options) {
   }
   const { createBunDevServer } = await import("@vertz/ui-server/bun-dev-server");
   let apiHandler;
+  let sessionResolver;
   if (mode.kind === "full-stack") {
     const serverMod = await importServerModule(mode.serverEntry);
     apiHandler = serverMod.handler;
+    sessionResolver = serverMod.sessionResolver;
   }
   const uiEntry = `./${relative(detected.projectRoot, mode.uiEntry)}`;
   const clientEntry = mode.clientEntry ? `/${relative(detected.projectRoot, mode.clientEntry)}` : undefined;
-  const openapiPath = join4(detected.projectRoot, ".vertz/generated/openapi.json");
+  const openapiPath = join5(detected.projectRoot, ".vertz/generated/openapi.json");
   const openapi = existsSync5(openapiPath) ? { specPath: openapiPath } : undefined;
   const devServer = createBunDevServer({
     entry: uiEntry,
     port,
     host,
     apiHandler,
+    sessionResolver,
     openapi,
     ssrModule: mode.ssrModule,
     clientEntry,
@@ -1451,10 +1636,10 @@ function startApiOnlyServer(serverEntry, port) {
     stdio: "inherit"
   }));
   pm.start(serverEntry, { PORT: String(port) });
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const shutdown = async () => {
       await pm.stop();
-      resolve3();
+      resolve4();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -1528,7 +1713,7 @@ async function devAction(options = {}) {
       }
     }
     const _watcher = createPipelineWatcher({
-      dir: join5(projectRoot, "src"),
+      dir: join6(projectRoot, "src"),
       debounceMs: 100,
       onChange: async (changes) => {
         if (!isRunning)
@@ -1650,34 +1835,35 @@ function generateAction(options) {
 }
 
 // src/commands/start.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync } from "node:fs";
-import { join as join6, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join7, resolve as resolve4 } from "node:path";
 import { err as err7, ok as ok7 } from "@vertz/errors";
 function discoverSSRModule(projectRoot) {
-  const serverDir = join6(projectRoot, "dist", "server");
+  const serverDir = join7(projectRoot, "dist", "server");
   if (!existsSync6(serverDir))
     return;
-  const files = readdirSync2(serverDir).filter((f) => f.endsWith(".js"));
+  const files = readdirSync3(serverDir).filter((f) => f.endsWith(".js"));
   if (files.length === 0)
     return;
   if (files.includes("app.js")) {
-    return join6(serverDir, "app.js");
+    return join7(serverDir, "app.js");
   }
   const first = files[0];
-  return first ? join6(serverDir, first) : undefined;
+  return first ? join7(serverDir, first) : undefined;
 }
 function validateBuildOutputs(projectRoot, appType) {
   const missing = [];
   if (appType === "api-only" || appType === "full-stack") {
-    const apiBuild = join6(projectRoot, ".vertz", "build", "index.js");
+    const apiBuild = join7(projectRoot, ".vertz", "build", "index.js");
     if (!existsSync6(apiBuild)) {
       missing.push(".vertz/build/index.js");
     }
   }
   if (appType === "ui-only" || appType === "full-stack") {
-    const clientHtml = join6(projectRoot, "dist", "client", "index.html");
-    if (!existsSync6(clientHtml)) {
-      missing.push("dist/client/index.html");
+    const shellHtml = join7(projectRoot, "dist", "client", "_shell.html");
+    const clientHtml = join7(projectRoot, "dist", "client", "index.html");
+    if (!existsSync6(shellHtml) && !existsSync6(clientHtml)) {
+      missing.push("dist/client/_shell.html");
     }
     const ssrModule = discoverSSRModule(projectRoot);
     if (!ssrModule) {
@@ -1722,7 +1908,7 @@ async function startAction(options = {}) {
   }
 }
 async function startApiOnly(projectRoot, port, host, _verbose) {
-  const entryPath = resolve3(projectRoot, ".vertz", "build", "index.js");
+  const entryPath = resolve4(projectRoot, ".vertz", "build", "index.js");
   let mod;
   try {
     mod = await import(entryPath);
@@ -1747,8 +1933,10 @@ async function startUIOnly(projectRoot, port, host, _verbose) {
   if (!ssrModulePath) {
     return err7(new Error('No SSR module found in dist/server/. Run "vertz build" first.'));
   }
-  const templatePath = resolve3(projectRoot, "dist", "client", "index.html");
-  const template = readFileSync(templatePath, "utf-8");
+  const shellPath = resolve4(projectRoot, "dist", "client", "_shell.html");
+  const legacyPath = resolve4(projectRoot, "dist", "client", "index.html");
+  const templatePath = existsSync6(shellPath) ? shellPath : legacyPath;
+  const template = readFileSync3(templatePath, "utf-8");
   let ssrModule;
   try {
     ssrModule = await import(ssrModulePath);
@@ -1762,16 +1950,22 @@ async function startUIOnly(projectRoot, port, host, _verbose) {
     template,
     inlineCSS
   });
-  const clientDir = resolve3(projectRoot, "dist", "client");
+  const clientDir = resolve4(projectRoot, "dist", "client");
   const server = Bun.serve({
     port,
     hostname: host,
     async fetch(req) {
       const url = new URL(req.url);
       const pathname = url.pathname;
+      if (req.headers.get("x-vertz-nav") === "1") {
+        return ssrHandler(req);
+      }
       const staticResponse = serveStaticFile(clientDir, pathname);
       if (staticResponse)
         return staticResponse;
+      const prerenderResponse = servePrerenderHTML(clientDir, pathname);
+      if (prerenderResponse)
+        return prerenderResponse;
       return ssrHandler(req);
     }
   });
@@ -1780,7 +1974,7 @@ async function startUIOnly(projectRoot, port, host, _verbose) {
   return ok7(undefined);
 }
 async function startFullStack(projectRoot, port, host, _verbose) {
-  const apiEntryPath = resolve3(projectRoot, ".vertz", "build", "index.js");
+  const apiEntryPath = resolve4(projectRoot, ".vertz", "build", "index.js");
   let apiMod;
   try {
     apiMod = await import(apiEntryPath);
@@ -1795,8 +1989,10 @@ async function startFullStack(projectRoot, port, host, _verbose) {
   if (!ssrModulePath) {
     return err7(new Error('No SSR module found in dist/server/. Run "vertz build" first.'));
   }
-  const templatePath = resolve3(projectRoot, "dist", "client", "index.html");
-  const template = readFileSync(templatePath, "utf-8");
+  const shellPath = resolve4(projectRoot, "dist", "client", "_shell.html");
+  const legacyPath = resolve4(projectRoot, "dist", "client", "index.html");
+  const templatePath = existsSync6(shellPath) ? shellPath : legacyPath;
+  const template = readFileSync3(templatePath, "utf-8");
   let ssrModule;
   try {
     ssrModule = await import(ssrModulePath);
@@ -1810,7 +2006,7 @@ async function startFullStack(projectRoot, port, host, _verbose) {
     template,
     inlineCSS
   });
-  const clientDir = resolve3(projectRoot, "dist", "client");
+  const clientDir = resolve4(projectRoot, "dist", "client");
   const server = Bun.serve({
     port,
     hostname: host,
@@ -1820,9 +2016,15 @@ async function startFullStack(projectRoot, port, host, _verbose) {
       if (pathname.startsWith("/api")) {
         return apiHandler(req);
       }
+      if (req.headers.get("x-vertz-nav") === "1") {
+        return ssrHandler(req);
+      }
       const staticResponse = serveStaticFile(clientDir, pathname);
       if (staticResponse)
         return staticResponse;
+      const prerenderResponse = servePrerenderHTML(clientDir, pathname);
+      if (prerenderResponse)
+        return prerenderResponse;
       return ssrHandler(req);
     }
   });
@@ -1831,25 +2033,43 @@ async function startFullStack(projectRoot, port, host, _verbose) {
   return ok7(undefined);
 }
 function discoverInlineCSS(projectRoot) {
-  const cssDir = resolve3(projectRoot, "dist", "client", "assets");
+  const cssDir = resolve4(projectRoot, "dist", "client", "assets");
   if (!existsSync6(cssDir))
     return;
-  const cssFiles = readdirSync2(cssDir).filter((f) => f.endsWith(".css"));
+  const cssFiles = readdirSync3(cssDir).filter((f) => f.endsWith(".css"));
   if (cssFiles.length === 0)
     return;
   const result = {};
   for (const file of cssFiles) {
-    const content = readFileSync(join6(cssDir, file), "utf-8");
+    const content = readFileSync3(join7(cssDir, file), "utf-8");
     result[`/assets/${file}`] = content;
   }
   return result;
 }
+function servePrerenderHTML(clientDir, pathname) {
+  const htmlPath = pathname === "/" ? resolve4(clientDir, "index.html") : resolve4(clientDir, `${pathname.replace(/^\//, "")}/index.html`);
+  if (!htmlPath.startsWith(clientDir))
+    return null;
+  if (htmlPath.endsWith("/_shell.html"))
+    return null;
+  const file = Bun.file(htmlPath);
+  if (!file.size)
+    return null;
+  return new Response(file, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "public, max-age=0, must-revalidate"
+    }
+  });
+}
 function serveStaticFile(clientDir, pathname) {
   if (pathname === "/" || pathname === "/index.html")
     return null;
-  const filePath = resolve3(clientDir, `.${pathname}`);
+  const filePath = resolve4(clientDir, `.${pathname}`);
   if (!filePath.startsWith(clientDir))
     return null;
+  if (!existsSync6(filePath) || !statSync2(filePath).isFile())
+    return null;
   const file = Bun.file(filePath);
   if (!file.size)
     return null;
@@ -1944,12 +2164,12 @@ function createCLI() {
     }
   });
   program.command("codegen").description("Generate SDK and CLI clients from the compiled API").option("--dry-run", "Preview generated files without writing").option("--output <dir>", "Output directory").action(async (opts) => {
-    const { resolve: resolve4, dirname: dirname2 } = await import("node:path");
+    const { resolve: resolve5, dirname: dirname3 } = await import("node:path");
     const { mkdir, writeFile: fsWriteFile } = await import("node:fs/promises");
     let config;
     let compilerConfig;
     try {
-      const configPath = resolve4(process.cwd(), "vertz.config.ts");
+      const configPath = resolve5(process.cwd(), "vertz.config.ts");
       const jiti = createJiti(import.meta.url);
       const configModule = await jiti.import(configPath);
       config = configModule.codegen ?? configModule.default?.codegen;
@@ -1974,7 +2194,7 @@ function createCLI() {
     const { createCodegenPipeline: createCodegenPipeline2 } = await import("@vertz/codegen");
     const pipeline = createCodegenPipeline2();
     const writeFile = async (path, content) => {
-      await mkdir(dirname2(path), { recursive: true });
+      await mkdir(dirname3(path), { recursive: true });
       await fsWriteFile(path, content, "utf-8");
     };
     const result = await codegenAction({
@@ -2075,8 +2295,8 @@ Schema is in sync.`);
     if (!opts.force) {
       const readline = await import("node:readline");
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve4) => {
-        rl.question("This will drop all tables and re-apply migrations. Continue? (y/N) ", resolve4);
+      const answer = await new Promise((resolve5) => {
+        rl.question("This will drop all tables and re-apply migrations. Continue? (y/N) ", resolve5);
       });
       rl.close();
       if (answer.toLowerCase() !== "y") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/cli",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "type": "module",
   "license": "MIT",
   "description": "Vertz CLI — dev, build, create, and deploy commands",
@@ -34,13 +34,13 @@
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"
   },
   "dependencies": {
-    "@vertz/codegen": "^0.2.14",
-    "@vertz/errors": "^0.2.14",
-    "@vertz/tui": "^0.2.14",
-    "@vertz/compiler": "^0.2.14",
-    "@vertz/create-vertz-app": "^0.2.14",
-    "@vertz/db": "^0.2.14",
-    "@vertz/ui-server": "^0.2.14",
+    "@vertz/codegen": "^0.2.16",
+    "@vertz/errors": "^0.2.16",
+    "@vertz/tui": "^0.2.16",
+    "@vertz/compiler": "^0.2.16",
+    "@vertz/create-vertz-app": "^0.2.16",
+    "@vertz/db": "^0.2.16",
+    "@vertz/ui-server": "^0.2.16",
     "esbuild": "^0.25.0",
     "commander": "^14.0.0",
     "jiti": "^2.4.2"