@cloudwerk/cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -4,8 +4,8 @@
 import { program } from "commander";
 
 // src/commands/dev.ts
-import * as path9 from "path";
-import * as fs8 from "fs";
+import * as path10 from "path";
+import * as fs10 from "fs";
 import * as os from "os";
 import { serve } from "@hono/node-server";
 import {
@@ -14,7 +14,7 @@ import {
   buildRouteManifest,
   resolveLayouts,
   resolveMiddleware,
-  resolveRoutesDir,
+  resolveRoutesDir as resolveRoutesDir2,
   hasErrors,
   formatErrors,
   formatWarnings
@@ -112,11 +112,11 @@ function printError(message, suggestion) {
   }
   console.log();
 }
-function logRequest(method, path10, status, duration) {
+function logRequest(method, path16, status, duration) {
   const methodColor = getMethodColor(method);
   const statusColor = status >= 400 ? pc.red : status >= 300 ? pc.yellow : pc.green;
   console.log(
-    pc.dim("[") + methodColor(method.padEnd(6)) + pc.dim("]") + " " + path10 + " " + statusColor(String(status)) + " " + pc.dim(`${duration}ms`)
+    pc.dim("[") + methodColor(method.padEnd(6)) + pc.dim("]") + " " + path16 + " " + statusColor(String(status)) + " " + pc.dim(`${duration}ms`)
   );
 }
 
@@ -237,26 +237,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/utils/url.js
-var splitPath = (path10) => {
-  const paths = path10.split("/");
+var splitPath = (path16) => {
+  const paths = path16.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path10 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path10);
+  const { groups, path: path16 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path16);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path10) => {
+var extractGroupsFromPath = (path16) => {
   const groups = [];
-  path10 = path10.replace(/\{[^}]+\}/g, (match2, index) => {
+  path16 = path16.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path10 };
+  return { groups, path: path16 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -311,8 +311,8 @@ var getPath = (request) => {
     const charCode = url.charCodeAt(i);
     if (charCode === 37) {
       const queryIndex = url.indexOf("?", i);
-      const path10 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path10.includes("%25") ? path10.replace(/%25/g, "%2525") : path10);
+      const path16 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path16.includes("%25") ? path16.replace(/%25/g, "%2525") : path16);
     } else if (charCode === 63) {
       break;
     }
@@ -329,11 +329,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path10) => {
-  if (path10.charCodeAt(path10.length - 1) !== 63 || !path10.includes(":")) {
+var checkOptionalParameter = (path16) => {
+  if (path16.charCodeAt(path16.length - 1) !== 63 || !path16.includes(":")) {
     return null;
   }
-  const segments = path10.split("/");
+  const segments = path16.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -474,9 +474,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path10 = "/", matchResult = [[]]) {
+  constructor(request, path16 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path10;
+    this.path = path16;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1212,8 +1212,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path10, ...handlers) => {
-      for (const p of [path10].flat()) {
+    this.on = (method, path16, ...handlers) => {
+      for (const p of [path16].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -1270,8 +1270,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path10, app) {
-    const subApp = this.basePath(path10);
+  route(path16, app) {
+    const subApp = this.basePath(path16);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -1297,9 +1297,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path10) {
+  basePath(path16) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path10);
+    subApp._basePath = mergePath(this._basePath, path16);
     return subApp;
   }
   /**
@@ -1373,7 +1373,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path10, applicationHandler, options) {
+  mount(path16, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -1400,7 +1400,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path10);
+      const mergedPath = mergePath(this._basePath, path16);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -1415,14 +1415,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path10, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path16, "*"), handler);
     return this;
   }
-  #addRoute(method, path10, handler) {
+  #addRoute(method, path16, handler) {
     method = method.toUpperCase();
-    path10 = mergePath(this._basePath, path10);
-    const r = { basePath: this._basePath, path: path10, method, handler };
-    this.router.add(method, path10, [handler, r]);
+    path16 = mergePath(this._basePath, path16);
+    const r = { basePath: this._basePath, path: path16, method, handler };
+    this.router.add(method, path16, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -1435,10 +1435,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path10 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path10);
+    const path16 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path16);
     const c = new Context(request, {
-      path: path10,
+      path: path16,
       matchResult,
       env,
       executionCtx,
@@ -1538,7 +1538,7 @@ var Hono = class _Hono {
 
 // ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path10) {
+function match(method, path16) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -1554,7 +1554,7 @@ function match(method, path10) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path10);
+  return match2(method, path16);
 }
 
 // ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -1669,12 +1669,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path10, index, pathErrorCheckOnly) {
+  insert(path16, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path10 = path10.replace(/\{[^}]+\}/g, (m) => {
+      path16 = path16.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -1685,7 +1685,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path10.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path16.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -1724,9 +1724,9 @@ var Trie = class {
 // ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path10) {
-  return wildcardRegExpCache[path10] ??= new RegExp(
-    path10 === "*" ? "" : `^${path10.replace(
+function buildWildcardRegExp(path16) {
+  return wildcardRegExpCache[path16] ??= new RegExp(
+    path16 === "*" ? "" : `^${path16.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -1748,17 +1748,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path10, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path16, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path10] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path16] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path10, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path16, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path10) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path16) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -1792,12 +1792,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path10) {
+function findMiddleware(middleware, path16) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path10)) {
+    if (buildWildcardRegExp(k).test(path16)) {
       return [...middleware[k]];
     }
   }
@@ -1811,7 +1811,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path10, handler) {
+  add(method, path16, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -1826,18 +1826,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path10 === "/*") {
-      path10 = "*";
+    if (path16 === "/*") {
+      path16 = "*";
     }
-    const paramCount = (path10.match(/\/:/g) || []).length;
-    if (/\*$/.test(path10)) {
-      const re = buildWildcardRegExp(path10);
+    const paramCount = (path16.match(/\/:/g) || []).length;
+    if (/\*$/.test(path16)) {
+      const re = buildWildcardRegExp(path16);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path10] ||= findMiddleware(middleware[m], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
+          middleware[m][path16] ||= findMiddleware(middleware[m], path16) || findMiddleware(middleware[METHOD_NAME_ALL], path16) || [];
         });
       } else {
-        middleware[method][path10] ||= findMiddleware(middleware[method], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
+        middleware[method][path16] ||= findMiddleware(middleware[method], path16) || findMiddleware(middleware[METHOD_NAME_ALL], path16) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -1855,7 +1855,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path10) || [path10];
+    const paths = checkOptionalParameter(path16) || [path16];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -1882,13 +1882,13 @@ var RegExpRouter = class {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
     [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path10) => [path10, r[method][path10]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path16) => [path16, r[method][path16]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path10) => [path10, r[METHOD_NAME_ALL][path10]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path16) => [path16, r[METHOD_NAME_ALL][path16]])
         );
       }
     });
@@ -1908,13 +1908,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path10, handler) {
+  add(method, path16, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path10, handler]);
+    this.#routes.push([method, path16, handler]);
   }
-  match(method, path10) {
+  match(method, path16) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -1929,7 +1929,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path10);
+        res = router.match(method, path16);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -1973,10 +1973,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path10, handler) {
+  insert(method, path16, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path10);
+    const parts = splitRoutingPath(path16);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -2027,12 +2027,12 @@ var Node2 = class _Node2 {
     }
     return handlerSets;
   }
-  search(method, path10) {
+  search(method, path16) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path10);
+    const parts = splitPath(path16);
     const curNodesQueue = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const part = parts[i];
@@ -2120,18 +2120,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path10, handler) {
-    const results = checkOptionalParameter(path10);
+  add(method, path16, handler) {
+    const results = checkOptionalParameter(path16);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path10, handler);
+    this.#node.insert(method, path16, handler);
   }
-  match(method, path10) {
-    return this.#node.search(method, path10);
+  match(method, path16) {
+    return this.#node.search(method, path16);
   }
 };
 
@@ -2151,7 +2151,7 @@ var Hono2 = class extends Hono {
 };
 
 // src/server/createApp.ts
-import { contextMiddleware } from "@cloudwerk/core";
+import { contextMiddleware, resolveRoutesDir } from "@cloudwerk/core";
 import { setActiveRenderer, getAvailableRenderers } from "@cloudwerk/ui";
 
 // src/server/registerRoutes.ts
@@ -2165,7 +2165,13 @@ import {
   resolveNotFoundBoundary,
   resolveLoadingBoundary
 } from "@cloudwerk/core";
-import { render, renderStream } from "@cloudwerk/ui";
+import {
+  render,
+  renderStream,
+  renderToStream,
+  generateHydrationScript,
+  generatePreloadHints
+} from "@cloudwerk/ui";
 
 // src/server/loadHandler.ts
 import * as fs from "fs";
@@ -2347,7 +2353,7 @@ import * as path3 from "path";
 import { builtinModules as builtinModules3 } from "module";
 import { build as build3 } from "esbuild";
 import { pathToFileURL as pathToFileURL3 } from "url";
-import { validateRouteConfig as validateRouteConfig2 } from "@cloudwerk/core";
+import { validateRouteConfig as validateRouteConfig2, hasUseClientDirective, generateComponentId, validateComponentBoundaries, handleBoundaryValidationResult } from "@cloudwerk/core";
 var pageModuleCache = /* @__PURE__ */ new Map();
 async function loadPageModule(absolutePath, verbose = false) {
   try {
@@ -2387,6 +2393,11 @@ async function loadPageModule(absolutePath, verbose = false) {
       throw new Error("No output from esbuild");
     }
     const code = result.outputFiles[0].text;
+    const sourceCode = fs3.readFileSync(absolutePath, "utf-8");
+    const isClientComponent = hasUseClientDirective(sourceCode);
+    const clientComponentId = isClientComponent ? generateComponentId(absolutePath, path3.dirname(absolutePath)) : void 0;
+    const validationResult = validateComponentBoundaries(sourceCode, absolutePath, isClientComponent);
+    handleBoundaryValidationResult(validationResult, absolutePath, { verbose });
     const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const tempDir = findSafeTempDir3(absolutePath);
     const tempFile = path3.join(tempDir, `.cloudwerk-page-${cacheKey}.mjs`);
@@ -2435,12 +2446,24 @@ async function loadPageModule(absolutePath, verbose = false) {
           validatedMethods[method] = rawModule[method];
         }
       }
+      let validatedGenerateStaticParams = void 0;
+      if ("generateStaticParams" in rawModule && rawModule.generateStaticParams !== void 0) {
+        if (typeof rawModule.generateStaticParams !== "function") {
+          throw new Error(
+            `Page generateStaticParams export must be a function, got ${typeof rawModule.generateStaticParams}`
+          );
+        }
+        validatedGenerateStaticParams = rawModule.generateStaticParams;
+      }
       const module = {
         default: rawModule.default,
         config: validatedConfig,
         loader: validatedLoader,
         action: validatedAction,
-        ...validatedMethods
+        ...validatedMethods,
+        isClientComponent,
+        clientComponentId,
+        generateStaticParams: validatedGenerateStaticParams
       };
       pageModuleCache.set(absolutePath, { module, mtime });
       return module;
@@ -2474,6 +2497,7 @@ import * as path4 from "path";
 import { builtinModules as builtinModules4 } from "module";
 import { build as build4 } from "esbuild";
 import { pathToFileURL as pathToFileURL4 } from "url";
+import { hasUseClientDirective as hasUseClientDirective2, generateComponentId as generateComponentId2, validateComponentBoundaries as validateComponentBoundaries2, handleBoundaryValidationResult as handleBoundaryValidationResult2 } from "@cloudwerk/core";
 var layoutModuleCache = /* @__PURE__ */ new Map();
 async function loadLayoutModule(absolutePath, verbose = false) {
   try {
@@ -2513,6 +2537,11 @@ async function loadLayoutModule(absolutePath, verbose = false) {
       throw new Error("No output from esbuild");
     }
     const code = result.outputFiles[0].text;
+    const sourceCode = fs4.readFileSync(absolutePath, "utf-8");
+    const isClientComponent = hasUseClientDirective2(sourceCode);
+    const clientComponentId = isClientComponent ? generateComponentId2(absolutePath, path4.dirname(absolutePath)) : void 0;
+    const validationResult = validateComponentBoundaries2(sourceCode, absolutePath, isClientComponent);
+    handleBoundaryValidationResult2(validationResult, absolutePath, { verbose });
     const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const tempDir = findSafeTempDir4(absolutePath);
     const tempFile = path4.join(tempDir, `.cloudwerk-layout-${cacheKey}.mjs`);
@@ -2538,7 +2567,9 @@ async function loadLayoutModule(absolutePath, verbose = false) {
       }
       const module = {
         default: rawModule.default,
-        loader: validatedLoader
+        loader: validatedLoader,
+        isClientComponent,
+        clientComponentId
       };
       layoutModuleCache.set(absolutePath, { module, mtime });
       return module;
@@ -2875,6 +2906,63 @@ function parseSearchParams(c) {
   return result;
 }
 
+// src/server/hydrationManifest.ts
+import * as fs8 from "fs";
+import { createHydrationManifest, addToHydrationManifest, hasUseClientDirective as hasUseClientDirective3, generateComponentId as generateComponentId3 } from "@cloudwerk/core";
+function createManifestTracker(appDir, basePath = "/__cloudwerk") {
+  return {
+    components: /* @__PURE__ */ new Map(),
+    basePath,
+    appDir
+  };
+}
+function trackIfClientComponent(tracker, filePath) {
+  if (tracker.components.has(filePath)) {
+    return true;
+  }
+  try {
+    const content = fs8.readFileSync(filePath, "utf-8");
+    if (hasUseClientDirective3(content)) {
+      const componentId = generateComponentId3(filePath, tracker.appDir);
+      tracker.components.set(filePath, {
+        filePath,
+        componentId,
+        exportName: "default",
+        bundled: false
+      });
+      return true;
+    }
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+function createRequestScopedManifest(tracker, usedComponentIds) {
+  const manifest = createHydrationManifest(tracker.basePath);
+  for (const component of tracker.components.values()) {
+    if (usedComponentIds.has(component.componentId)) {
+      addToHydrationManifest(
+        manifest,
+        {
+          filePath: component.filePath,
+          componentId: component.componentId,
+          exportName: component.exportName
+        },
+        `${tracker.basePath}/${component.componentId}.js`
+      );
+    }
+  }
+  return manifest;
+}
+function getComponentByIdFromTracker(tracker, componentId) {
+  for (const component of tracker.components.values()) {
+    if (component.componentId === componentId) {
+      return component;
+    }
+  }
+  return void 0;
+}
+
 // src/server/registerRoutes.ts
 var HTTP_METHODS = [
   "GET",
@@ -2885,11 +2973,44 @@ var HTTP_METHODS = [
   "OPTIONS",
   "HEAD"
 ];
+async function injectHydrationScripts(response, hydrationCtx) {
+  if (hydrationCtx.usedComponentIds.size === 0) {
+    return response;
+  }
+  const manifest = createRequestScopedManifest(
+    hydrationCtx.tracker,
+    hydrationCtx.usedComponentIds
+  );
+  const preloadHints = generatePreloadHints(manifest);
+  const hydrationScript = generateHydrationScript(manifest);
+  if (!preloadHints && !hydrationScript) {
+    return response;
+  }
+  const html = await response.text();
+  let modifiedHtml = html;
+  if (preloadHints) {
+    const headEndIndex = modifiedHtml.indexOf("</head>");
+    if (headEndIndex !== -1) {
+      modifiedHtml = modifiedHtml.slice(0, headEndIndex) + "\n" + preloadHints + "\n" + modifiedHtml.slice(headEndIndex);
+    }
+  }
+  if (hydrationScript) {
+    const bodyEndIndex = modifiedHtml.lastIndexOf("</body>");
+    if (bodyEndIndex !== -1) {
+      modifiedHtml = modifiedHtml.slice(0, bodyEndIndex) + "\n" + hydrationScript + "\n" + modifiedHtml.slice(bodyEndIndex);
+    }
+  }
+  return new Response(modifiedHtml, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
 function isCloudwerkHandler(fn) {
   return typeof fn === "function" && fn.length === 2;
 }
 function createConfigMiddleware(config) {
-  return async (c, next) => {
+  return async (_c, next) => {
     setRouteConfig(config);
     await next();
   };
@@ -2919,7 +3040,7 @@ async function executeAction(action, args, c) {
     throw error;
   }
 }
-async function registerRoutes(app, manifest, scanResult, logger, verbose = false) {
+async function registerRoutes(app, manifest, scanResult, logger, verbose = false, hydrationTracker) {
   const registeredRoutes = [];
   for (const route of manifest.routes) {
     if (route.fileType === "page") {
@@ -2927,10 +3048,26 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
         logger.debug(`Loading page: ${route.filePath}`);
         const pageModule = await loadPageModule(route.absolutePath, verbose);
         const PageComponent = pageModule.default;
+        if (hydrationTracker && pageModule.isClientComponent) {
+          trackIfClientComponent(hydrationTracker, route.absolutePath);
+          if (verbose) {
+            logger.debug(`Tracked client component: ${route.filePath}`);
+          }
+        }
         const layoutModules = await Promise.all(
           route.layouts.map((layoutPath) => loadLayoutModule(layoutPath, verbose))
         );
         const layouts = layoutModules.map((m) => m.default);
+        if (hydrationTracker) {
+          for (let i = 0; i < layoutModules.length; i++) {
+            if (layoutModules[i].isClientComponent) {
+              trackIfClientComponent(hydrationTracker, route.layouts[i]);
+              if (verbose) {
+                logger.debug(`Tracked client layout: ${route.layouts[i]}`);
+              }
+            }
+          }
+        }
         const loadingPath = resolveLoadingBoundary(route.filePath, scanResult.loading);
         let loadingModule = null;
         if (loadingPath) {
@@ -2967,9 +3104,18 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
           const request = c.req.raw;
           const pathname = new URL(request.url).pathname;
           const layoutLoaderData = [];
+          const hydrationCtx = hydrationTracker ? { usedComponentIds: /* @__PURE__ */ new Set(), tracker: hydrationTracker } : null;
+          if (hydrationCtx && pageModule.isClientComponent && pageModule.clientComponentId) {
+            hydrationCtx.usedComponentIds.add(pageModule.clientComponentId);
+          }
+          for (const layoutModule of layoutModules) {
+            if (hydrationCtx && layoutModule.isClientComponent && layoutModule.clientComponentId) {
+              hydrationCtx.usedComponentIds.add(layoutModule.clientComponentId);
+            }
+          }
           const streamingDisabled = pageModule.config?.streaming === false;
           const useStreaming = loadingModule && !streamingDisabled;
-          if (useStreaming) {
+          if (useStreaming && loadingModule) {
             try {
               const LoadingComponent = loadingModule.default;
               const loadingProps = { params, searchParams, pathname };
@@ -3057,7 +3203,11 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
               };
               element = await Promise.resolve(Layout(layoutProps));
             }
-            return render(element);
+            const response = await renderToStream(element);
+            if (hydrationCtx && hydrationCtx.usedComponentIds.size > 0) {
+              return injectHydrationScripts(response, hydrationCtx);
+            }
+            return response;
           } catch (error) {
             if (error instanceof NotFoundError) {
               const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
@@ -3144,6 +3294,15 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
               const searchParams = parseSearchParams(c);
               const request = c.req.raw;
               const layoutLoaderData = [];
+              const actionHydrationCtx = hydrationTracker ? { usedComponentIds: /* @__PURE__ */ new Set(), tracker: hydrationTracker } : null;
+              if (actionHydrationCtx && pageModule.isClientComponent && pageModule.clientComponentId) {
+                actionHydrationCtx.usedComponentIds.add(pageModule.clientComponentId);
+              }
+              for (const layoutModule of layoutModules) {
+                if (actionHydrationCtx && layoutModule.isClientComponent && layoutModule.clientComponentId) {
+                  actionHydrationCtx.usedComponentIds.add(layoutModule.clientComponentId);
+                }
+              }
               try {
                 const actionArgs = { params, request, context: c };
                 const actionResult = await executeAction(actionFn, actionArgs, c);
@@ -3187,7 +3346,11 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
                   };
                   element = await Promise.resolve(Layout(layoutProps));
                 }
-                return render(element);
+                const actionResponse = await renderToStream(element);
+                if (actionHydrationCtx && actionHydrationCtx.usedComponentIds.size > 0) {
+                  return injectHydrationScripts(actionResponse, actionHydrationCtx);
+                }
+                return actionResponse;
               } catch (error) {
                 if (error instanceof NotFoundError) {
                   const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
@@ -3340,6 +3503,145 @@ function registerMethod(app, method, pattern, handler) {
   }
 }
 
+// src/server/hydrationRoutes.ts
+import {
+  generateHydrationRuntime as generateHydrationRuntime2,
+  generateReactHydrationRuntime as generateReactHydrationRuntime2
+} from "@cloudwerk/ui";
+
+// src/server/clientBundle.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import { createRequire } from "module";
+import { build as build8 } from "esbuild";
+import { generateComponentId as generateComponentId4, createHydrationManifest as createHydrationManifest2, addToHydrationManifest as addToHydrationManifest2 } from "@cloudwerk/core";
+import { generateHydrationRuntime, generateReactHydrationRuntime } from "@cloudwerk/ui";
+var require2 = createRequire(import.meta.url);
+var honoMainPath = require2.resolve("hono");
+function findNodeModulesDir(filePath) {
+  let dir = filePath;
+  while (dir !== path9.dirname(dir)) {
+    dir = path9.dirname(dir);
+    if (path9.basename(dir) === "node_modules") {
+      return dir;
+    }
+  }
+  return path9.join(path9.dirname(filePath), "..", "..");
+}
+var nodeModulesPath = findNodeModulesDir(honoMainPath);
+var bundleCache = /* @__PURE__ */ new Map();
+async function generateBundleOnDemand(componentPath, appDir, options = {}) {
+  const { renderer = "hono-jsx" } = options;
+  const cacheKey = `${componentPath}:${renderer}`;
+  const stat = fs9.statSync(componentPath);
+  const cached = bundleCache.get(cacheKey);
+  if (cached && cached.mtime === stat.mtimeMs) {
+    return {
+      content: cached.content,
+      componentId: generateComponentId4(componentPath, appDir)
+    };
+  }
+  const jsxImportSource = renderer === "react" ? "react" : "hono/jsx/dom";
+  const result = await build8({
+    entryPoints: [componentPath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "browser",
+    target: ["es2020", "chrome80", "firefox80", "safari14"],
+    jsx: "automatic",
+    jsxImportSource,
+    minify: false,
+    sourcemap: "inline",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("development")
+    },
+    logLevel: "silent",
+    // Resolve hono/react from the package's node_modules
+    nodePaths: [nodeModulesPath]
+  });
+  if (!result.outputFiles || result.outputFiles.length === 0) {
+    throw new Error("No output from esbuild");
+  }
+  const content = result.outputFiles[0].text;
+  const componentId = generateComponentId4(componentPath, appDir);
+  bundleCache.set(cacheKey, {
+    content,
+    mtime: stat.mtimeMs,
+    bundlePath: `/__cloudwerk/${componentId}.js`
+  });
+  return { content, componentId };
+}
+
+// src/server/hydrationRoutes.ts
+var runtimeCache = /* @__PURE__ */ new Map();
+function registerHydrationRoutes(app, options) {
+  const { tracker, appDir, logger, verbose = false, renderer = "hono-jsx" } = options;
+  app.get("/__cloudwerk/runtime.js", (c) => {
+    if (verbose) {
+      logger.debug("Serving Hono JSX hydration runtime");
+    }
+    let runtime = runtimeCache.get("hono-jsx");
+    if (!runtime) {
+      runtime = generateHydrationRuntime2();
+      runtimeCache.set("hono-jsx", runtime);
+    }
+    return c.text(runtime, 200, {
+      "Content-Type": "application/javascript; charset=utf-8",
+      "Cache-Control": "public, max-age=31536000, immutable"
+    });
+  });
+  app.get("/__cloudwerk/react-runtime.js", (c) => {
+    if (verbose) {
+      logger.debug("Serving React hydration runtime");
+    }
+    let runtime = runtimeCache.get("react");
+    if (!runtime) {
+      runtime = generateReactHydrationRuntime2();
+      runtimeCache.set("react", runtime);
+    }
+    return c.text(runtime, 200, {
+      "Content-Type": "application/javascript; charset=utf-8",
+      "Cache-Control": "public, max-age=31536000, immutable"
+    });
+  });
+  app.get("/__cloudwerk/:componentId{.+\\.js$}", async (c) => {
+    const componentIdWithExt = c.req.param("componentId");
+    const componentId = componentIdWithExt.replace(/\.js$/, "");
+    if (verbose) {
+      logger.debug(`Serving component bundle: ${componentId}`);
+    }
+    const component = getComponentByIdFromTracker(tracker, componentId);
+    if (!component) {
+      logger.warn(`[Cloudwerk] Component not found: ${componentId}`);
+      return c.text(`// Component not found: ${componentId}`, 404, {
+        "Content-Type": "application/javascript; charset=utf-8"
+      });
+    }
+    try {
+      const { content } = await generateBundleOnDemand(
+        component.filePath,
+        appDir,
+        { renderer }
+      );
+      return c.text(content, 200, {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Cache-Control": "no-cache"
+        // Dev mode - always check for updates
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`[Cloudwerk] Failed to bundle component ${componentId}: ${message}`);
+      return c.text(`// Bundle error: ${message}`, 500, {
+        "Content-Type": "application/javascript; charset=utf-8"
+      });
+    }
+  });
+  if (verbose) {
+    logger.info("Registered hydration routes at /__cloudwerk/*");
+  }
+}
+
 // src/constants.ts
 var DEFAULT_PORT = 3e3;
 var DEFAULT_HOST = "localhost";
@@ -3381,7 +3683,16 @@ async function createApp(manifest, scanResult, config, logger, verbose = false)
       app.use("*", middleware);
     }
   }
-  const routes = await registerRoutes(app, manifest, scanResult, logger, verbose);
+  const appDir = resolveRoutesDir(config, manifest.rootDir);
+  const hydrationTracker = createManifestTracker(appDir);
+  registerHydrationRoutes(app, {
+    tracker: hydrationTracker,
+    appDir,
+    logger,
+    verbose,
+    renderer: rendererName === "react" ? "react" : "hono-jsx"
+  });
+  const routes = await registerRoutes(app, manifest, scanResult, logger, verbose, hydrationTracker);
   app.notFound((c) => {
     return c.json(
       {
@@ -3407,9 +3718,9 @@ async function createApp(manifest, scanResult, config, logger, verbose = false)
 }
 
 // src/version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var pkg = require3("../package.json");
 var VERSION = pkg.version;
 
 // src/commands/dev.ts
@@ -3418,8 +3729,8 @@ async function dev(pathArg, options) {
   const verbose = options.verbose ?? false;
   const logger = createLogger(verbose);
   try {
-    const cwd = pathArg ? path9.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs8.existsSync(cwd)) {
+    const cwd = pathArg ? path10.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs10.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -3430,9 +3741,9 @@ async function dev(pathArg, options) {
     logger.debug(`Loading configuration...`);
     const config = await loadConfig(cwd);
     logger.debug(`Config loaded: routesDir=${config.routesDir}, extensions=${config.extensions.join(", ")}`);
-    const routesDir = resolveRoutesDir(config, cwd);
+    const routesDir = resolveRoutesDir2(config, cwd);
     logger.debug(`Routes directory: ${routesDir}`);
-    if (!fs8.existsSync(routesDir)) {
+    if (!fs10.existsSync(routesDir)) {
       throw new CliError(
         `Routes directory does not exist: ${routesDir}`,
         "ENOENT",
@@ -3496,8 +3807,8 @@ async function dev(pathArg, options) {
         process.exit(1);
       }
     });
-    await new Promise((resolve2) => {
-      server.on("listening", resolve2);
+    await new Promise((resolve3) => {
+      server.on("listening", resolve3);
     });
     const startupTime = Date.now() - startTime;
     const localUrl = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}/`;
@@ -3556,7 +3867,892 @@ function setupGracefulShutdown(server, logger) {
   process.on("SIGTERM", shutdown);
 }
 
+// src/commands/build.ts
+import * as path12 from "path";
+import * as fs12 from "fs";
+import {
+  loadConfig as loadConfig2,
+  scanRoutes as scanRoutes2,
+  buildRouteManifest as buildRouteManifest2,
+  resolveLayouts as resolveLayouts2,
+  resolveMiddleware as resolveMiddleware2,
+  resolveRoutesDir as resolveRoutesDir3,
+  hasErrors as hasErrors2,
+  formatErrors as formatErrors2,
+  formatWarnings as formatWarnings2
+} from "@cloudwerk/core";
+
+// src/server/ssg.ts
+import * as fs11 from "fs/promises";
+import * as path11 from "path";
+async function getStaticRoutesAsync(manifest, logger) {
+  const staticRoutes = [];
+  for (const route of manifest.routes) {
+    if (route.fileType !== "page") {
+      continue;
+    }
+    try {
+      const module = await loadPageModule(route.absolutePath);
+      if (module.config?.rendering === "static") {
+        staticRoutes.push({ route, module });
+        logger?.debug(`Found static route: ${route.urlPattern}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger?.warn(`Failed to load page module for ${route.urlPattern}: ${errorMessage}`);
+    }
+  }
+  return staticRoutes;
+}
+function hasDynamicSegments(segments) {
+  return segments.some(
+    (segment) => segment.type === "dynamic" || segment.type === "catchAll" || segment.type === "optionalCatchAll"
+  );
+}
+function interpolatePath(urlPattern, params) {
+  let result = urlPattern;
+  for (const [key, value] of Object.entries(params)) {
+    const encodedValue = encodeURIComponent(value);
+    result = result.replace(`:${key}`, encodedValue);
+    result = result.replace(`*${key}`, encodedValue);
+  }
+  return result;
+}
+function urlPathToOutputFile(urlPath) {
+  let normalizedPath = urlPath;
+  if (normalizedPath.startsWith("/")) {
+    normalizedPath = normalizedPath.slice(1);
+  }
+  if (normalizedPath === "") {
+    return "index.html";
+  }
+  return path11.join(normalizedPath, "index.html");
+}
+async function generateStaticSite(app, manifest, outputDir, logger, verbose = false) {
+  const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
+  const results = [];
+  await fs11.mkdir(outputDir, { recursive: true });
+  for (const { route, module } of staticRoutes) {
+    try {
+      const urlPaths = await getUrlPathsForRouteWithModule(route, module, verbose ? logger : void 0);
+      for (const urlPath of urlPaths) {
+        const result = await generateStaticPage(app, urlPath, outputDir, logger, verbose);
+        results.push(result);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to generate static pages for ${route.urlPattern}: ${errorMessage}`);
+      results.push({
+        urlPath: route.urlPattern,
+        outputFile: urlPathToOutputFile(route.urlPattern),
+        success: false,
+        error: errorMessage
+      });
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failureCount = results.filter((r) => !r.success).length;
+  return {
+    totalPages: results.length,
+    successCount,
+    failureCount,
+    routes: results,
+    outputDir
+  };
+}
+async function getUrlPathsForRouteWithModule(route, module, logger) {
+  if (!hasDynamicSegments(route.segments)) {
+    return [route.urlPattern];
+  }
+  if (!module.generateStaticParams) {
+    logger?.warn(
+      `Static route ${route.urlPattern} has dynamic segments but no generateStaticParams export. Skipping.`
+    );
+    return [];
+  }
+  const paramsList = await module.generateStaticParams({});
+  if (!Array.isArray(paramsList)) {
+    throw new Error(
+      `generateStaticParams must return an array, got ${typeof paramsList}`
+    );
+  }
+  const urlPaths = paramsList.map((params) => {
+    if (typeof params !== "object" || params === null) {
+      throw new Error(
+        `generateStaticParams must return array of objects, got ${typeof params}`
+      );
+    }
+    return interpolatePath(route.urlPattern, params);
+  });
+  logger?.debug(`Generated ${urlPaths.length} paths for ${route.urlPattern}`);
+  return urlPaths;
+}
+async function generateStaticPage(app, urlPath, outputDir, logger, verbose) {
+  const outputFile = urlPathToOutputFile(urlPath);
+  const outputPath = path11.join(outputDir, outputFile);
+  try {
+    const url = `http://localhost${urlPath}`;
+    const request = new Request(url, { method: "GET" });
+    const response = await app.fetch(request);
+    if (!response.ok) {
+      throw new Error(`Request failed with status ${response.status}`);
+    }
+    const html = await response.text();
+    await fs11.mkdir(path11.dirname(outputPath), { recursive: true });
+    await fs11.writeFile(outputPath, html, "utf-8");
+    if (verbose) {
+      logger.debug(`Generated: ${outputFile}`);
+    }
+    return {
+      urlPath,
+      outputFile,
+      success: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to generate ${urlPath}: ${errorMessage}`);
+    return {
+      urlPath,
+      outputFile,
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+
+// src/commands/build.ts
+var DEFAULT_OUTPUT_DIR = "./dist";
+var STATIC_SUBDIR = "static";
+async function build9(pathArg, options) {
+  const startTime = Date.now();
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = pathArg ? path12.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs12.existsSync(cwd)) {
+      throw new CliError(
+        `Directory does not exist: ${cwd}`,
+        "ENOENT",
+        `Make sure the path exists and try again.`
+      );
+    }
+    logger.debug(`Working directory: ${cwd}`);
+    logger.debug(`Loading configuration...`);
+    const config = await loadConfig2(cwd);
+    logger.debug(`Config loaded: routesDir=${config.routesDir}, extensions=${config.extensions.join(", ")}`);
+    const routesDir = resolveRoutesDir3(config, cwd);
+    logger.debug(`Routes directory: ${routesDir}`);
+    if (!fs12.existsSync(routesDir)) {
+      throw new CliError(
+        `Routes directory does not exist: ${routesDir}`,
+        "ENOENT",
+        `Create the "${config.routesDir}" directory or update routesDir in cloudwerk.config.ts`
+      );
+    }
+    logger.debug(`Scanning routes...`);
+    const scanResult = await scanRoutes2(routesDir, config);
+    logger.debug(`Found ${scanResult.routes.length} route files`);
+    logger.debug(`Building route manifest...`);
+    const manifest = buildRouteManifest2(
+      scanResult,
+      routesDir,
+      resolveLayouts2,
+      resolveMiddleware2
+    );
+    if (hasErrors2(manifest)) {
+      const errorMessages = formatErrors2(manifest.errors);
+      logger.error(errorMessages);
+      throw new CliError(
+        "Route validation failed",
+        "VALIDATION_ERROR",
+        "Fix the errors above and try again."
+      );
+    }
+    if (manifest.warnings.length > 0) {
+      const warningMessages = formatWarnings2(manifest.warnings);
+      logger.warn(warningMessages);
+    }
+    if (manifest.routes.length === 0) {
+      logger.warn(`No routes found in ${config.routesDir}`);
+      logger.warn(`Create a route.ts file to get started.`);
+    }
+    const outputBase = options.output ?? DEFAULT_OUTPUT_DIR;
+    const outputDir = path12.isAbsolute(outputBase) ? outputBase : path12.resolve(cwd, outputBase);
+    logger.info(`Building to ${outputDir}...`);
+    if (options.ssg) {
+      logger.debug(`Scanning for static routes...`);
+      const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
+      if (staticRoutes.length === 0) {
+        logger.warn(`No static routes found. Add rendering: 'static' to route configs to enable SSG.`);
+      } else {
+        logger.info(`Found ${staticRoutes.length} static route(s)`);
+        logger.debug(`Creating Hono app for SSG...`);
+        const { app } = await createApp(manifest, scanResult, config, logger, verbose);
+        const staticOutputDir = path12.join(outputDir, STATIC_SUBDIR);
+        logger.info(`Generating static pages to ${staticOutputDir}...`);
+        const ssgStartTime = Date.now();
+        const result = await generateStaticSite(app, manifest, staticOutputDir, logger, verbose);
+        const ssgDuration = Date.now() - ssgStartTime;
+        printSSGResults(result, logger, ssgDuration);
+        if (result.failureCount > 0) {
+          throw new CliError(
+            `Failed to generate ${result.failureCount} static page(s)`,
+            "SSG_ERROR",
+            "Check the errors above and fix any issues."
+          );
+        }
+      }
+    } else {
+      logger.debug(`Scanning for static routes...`);
+      const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
+      if (staticRoutes.length > 0) {
+        logger.info(`Found ${staticRoutes.length} static route(s). Use --ssg to generate static pages.`);
+      }
+    }
+    const buildTime = Date.now() - startTime;
+    logger.success(`Build completed in ${buildTime}ms`);
+  } catch (error) {
+    if (error instanceof CliError) {
+      printError(error.message, error.suggestion);
+      process.exit(1);
+    }
+    if (error instanceof Error) {
+      printError(error.message);
+      if (verbose && error.stack) {
+        console.log(error.stack);
+      }
+      process.exit(1);
+    }
+    printError(String(error));
+    process.exit(1);
+  }
+}
+function printSSGResults(result, logger, duration) {
+  console.log();
+  logger.log("Static Site Generation Results:");
+  logger.log(`  Total pages: ${result.totalPages}`);
+  logger.log(`  Generated: ${result.successCount}`);
+  if (result.failureCount > 0) {
+    logger.log(`  Failed: ${result.failureCount}`);
+  }
+  logger.log(`  Output: ${result.outputDir}`);
+  logger.log(`  Duration: ${duration}ms`);
+  const pagesToShow = result.routes.filter((r) => r.success).slice(0, 10);
+  if (pagesToShow.length > 0) {
+    console.log();
+    logger.log("Generated pages:");
+    for (const page of pagesToShow) {
+      logger.log(`  ${page.urlPath} -> ${page.outputFile}`);
+    }
+    if (result.successCount > 10) {
+      logger.log(`  ... and ${result.successCount - 10} more`);
+    }
+  }
+  const failedPages = result.routes.filter((r) => !r.success);
+  if (failedPages.length > 0) {
+    console.log();
+    logger.error("Failed pages:");
+    for (const page of failedPages) {
+      logger.error(`  ${page.urlPath}: ${page.error}`);
+    }
+  }
+}
+
+// src/commands/config.ts
+import * as readline from "readline";
+import pc2 from "picocolors";
+
+// src/utils/configWriter.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+import { loadConfig as loadConfig3 } from "@cloudwerk/core";
+var CONFIG_FILE_NAMES = [
+  "cloudwerk.config.ts",
+  "cloudwerk.config.js",
+  "cloudwerk.config.mjs"
+];
+function findConfigFile(cwd) {
+  for (const filename of CONFIG_FILE_NAMES) {
+    const configPath = path13.join(cwd, filename);
+    if (fs13.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function readCloudwerkConfig(cwd) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    return {};
+  }
+  const content = fs13.readFileSync(configPath, "utf-8");
+  return parseConfigContent(content);
+}
+function parseConfigContent(content) {
+  const result = {};
+  const rendererMatch = content.match(/renderer\s*:\s*['"`]([^'"`]+)['"`]/i);
+  if (rendererMatch) {
+    const value = rendererMatch[1];
+    if (value === "hono-jsx" || value === "react" || value === "preact") {
+      result.renderer = value;
+    }
+  }
+  const routesDirMatch = content.match(/routesDir\s*:\s*['"`]([^'"`]+)['"`]/i);
+  if (routesDirMatch) {
+    result.routesDir = routesDirMatch[1];
+  }
+  return result;
+}
+function writeCloudwerkConfig(cwd, updates) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    const newConfigPath = path13.join(cwd, "cloudwerk.config.ts");
+    const content2 = generateMinimalConfig(updates);
+    fs13.writeFileSync(newConfigPath, content2, "utf-8");
+    return true;
+  }
+  let content = fs13.readFileSync(configPath, "utf-8");
+  if (updates.renderer !== void 0) {
+    content = updateRenderer(content, updates.renderer);
+  }
+  fs13.writeFileSync(configPath, content, "utf-8");
+  return true;
+}
+function updateRenderer(content, renderer) {
+  const rendererPattern = /(renderer\s*:\s*)['"`][^'"`]*['"`]/;
+  if (rendererPattern.test(content)) {
+    return content.replace(rendererPattern, `$1'${renderer}'`);
+  }
+  const uiSectionPattern = /(ui\s*:\s*\{)/;
+  if (uiSectionPattern.test(content)) {
+    return content.replace(uiSectionPattern, `$1
+    renderer: '${renderer}',`);
+  }
+  return addUiSection(content, renderer);
+}
+function addUiSection(content, renderer) {
+  if (!content.includes("defineConfig")) {
+    return generateMinimalConfig({ renderer });
+  }
+  const lines = content.split("\n");
+  const result = [];
+  let inserted = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!inserted && (trimmed === "})" || trimmed.startsWith("})"))) {
+      const indent = detectIndentation(lines, i);
+      result.unshift(line);
+      result.unshift(`${indent}},`);
+      result.unshift(`${indent}  renderer: '${renderer}',`);
+      result.unshift(`${indent}ui: {`);
+      inserted = true;
+    } else {
+      result.unshift(line);
+    }
+  }
+  if (!inserted) {
+    return generateMinimalConfig({ renderer });
+  }
+  return result.join("\n");
+}
+function detectIndentation(lines, closingLineIndex) {
+  for (let i = closingLineIndex - 1; i >= 0; i--) {
+    const line = lines[i];
+    const match2 = line.match(/^(\s+)\S/);
+    if (match2) {
+      return match2[1];
+    }
+  }
+  return "  ";
+}
+function generateMinimalConfig(updates) {
+  const lines = [
+    "import { defineConfig } from '@cloudwerk/core'",
+    "",
+    "export default defineConfig({",
+    "  routesDir: 'app',"
+  ];
+  if (updates.renderer) {
+    lines.push("  ui: {");
+    lines.push(`    renderer: '${updates.renderer}',`);
+    lines.push("  },");
+  }
+  lines.push("})");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/utils/tsconfigWriter.ts
+import * as fs14 from "fs";
+import * as path14 from "path";
+function findTsConfig(cwd) {
+  const tsconfigPath = path14.join(cwd, "tsconfig.json");
+  if (fs14.existsSync(tsconfigPath)) {
+    return tsconfigPath;
+  }
+  return null;
+}
+function readTsConfig(cwd) {
+  const tsconfigPath = findTsConfig(cwd);
+  if (!tsconfigPath) {
+    return {};
+  }
+  try {
+    const content = fs14.readFileSync(tsconfigPath, "utf-8");
+    const config = JSON.parse(content);
+    return {
+      jsxImportSource: config.compilerOptions?.jsxImportSource,
+      ...config.compilerOptions
+    };
+  } catch {
+    return {};
+  }
+}
+function updateTsConfig(cwd, updates) {
+  const tsconfigPath = findTsConfig(cwd);
+  if (!tsconfigPath) {
+    return false;
+  }
+  try {
+    const content = fs14.readFileSync(tsconfigPath, "utf-8");
+    const config = JSON.parse(content);
+    if (!config.compilerOptions) {
+      config.compilerOptions = {};
+    }
+    if (updates.jsxImportSource !== void 0) {
+      config.compilerOptions.jsxImportSource = updates.jsxImportSource;
+    }
+    fs14.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/dependencyManager.ts
+import * as fs15 from "fs";
+import * as path15 from "path";
+import { execFileSync } from "child_process";
+var REACT_SPECIFIC_LIBRARIES = [
+  "@tanstack/react-query",
+  "framer-motion",
+  "react-hook-form",
+  "react-router",
+  "react-router-dom",
+  "@react-spring/core",
+  "@react-spring/web",
+  "@react-spring/three",
+  "react-redux",
+  "@reduxjs/toolkit",
+  "react-aria",
+  "react-stately",
+  "@react-aria/button",
+  "@react-aria/focus",
+  "@radix-ui/react-dialog",
+  "@radix-ui/react-dropdown-menu",
+  "@radix-ui/react-popover",
+  "@radix-ui/react-tooltip",
+  "@radix-ui/react-accordion",
+  "@headlessui/react",
+  "react-dnd",
+  "react-beautiful-dnd",
+  "react-virtualized",
+  "react-window",
+  "react-select",
+  "react-datepicker",
+  "react-toastify",
+  "react-i18next",
+  "styled-components",
+  "@emotion/react",
+  "@emotion/styled",
+  "jotai",
+  "zustand",
+  "recoil",
+  "use-gesture",
+  "@use-gesture/react"
+];
+function detectPackageManager(cwd) {
+  if (fs15.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs15.existsSync(path15.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (fs15.existsSync(path15.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (fs15.existsSync(path15.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  const packageJsonPath = path15.join(cwd, "package.json");
+  if (fs15.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
+      const pm = packageJson.packageManager;
+      if (pm) {
+        if (pm.startsWith("pnpm")) return "pnpm";
+        if (pm.startsWith("yarn")) return "yarn";
+        if (pm.startsWith("bun")) return "bun";
+        if (pm.startsWith("npm")) return "npm";
+      }
+    } catch {
+    }
+  }
+  return "npm";
+}
+function getInstalledDependencies(cwd) {
+  const packageJsonPath = path15.join(cwd, "package.json");
+  if (!fs15.existsSync(packageJsonPath)) {
+    return {
+      dependencies: {},
+      devDependencies: {}
+    };
+  }
+  try {
+    const content = fs15.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    return {
+      dependencies: packageJson.dependencies || {},
+      devDependencies: packageJson.devDependencies || {}
+    };
+  } catch {
+    return {
+      dependencies: {},
+      devDependencies: {}
+    };
+  }
+}
+function hasReactDependencies(cwd) {
+  const { dependencies, devDependencies } = getInstalledDependencies(cwd);
+  const allDeps = { ...dependencies, ...devDependencies };
+  const reactPackages = ["react", "react-dom", "@types/react", "@types/react-dom"];
+  const installedPackages = reactPackages.filter((pkg2) => pkg2 in allDeps);
+  return {
+    hasReact: "react" in allDeps,
+    hasReactDom: "react-dom" in allDeps,
+    hasTypes: "@types/react" in allDeps || "@types/react-dom" in allDeps,
+    installedPackages
+  };
+}
+function detectIncompatibleReactLibs(cwd) {
+  const { dependencies, devDependencies } = getInstalledDependencies(cwd);
+  const allDeps = { ...dependencies, ...devDependencies };
+  const incompatible = [];
+  for (const lib of REACT_SPECIFIC_LIBRARIES) {
+    if (lib in allDeps) {
+      incompatible.push(lib);
+    }
+  }
+  for (const pkg2 of Object.keys(allDeps)) {
+    if (pkg2.startsWith("@radix-ui/react-") && !incompatible.includes(pkg2)) {
+      incompatible.push(pkg2);
+    }
+  }
+  return incompatible.sort();
+}
+function buildInstallArgs(pm, packages, isDev) {
+  const args = [];
+  switch (pm) {
+    case "pnpm":
+      args.push("add");
+      if (isDev) args.push("-D");
+      args.push(...packages);
+      break;
+    case "yarn":
+      args.push("add");
+      if (isDev) args.push("-D");
+      args.push(...packages);
+      break;
+    case "bun":
+      args.push("add");
+      if (isDev) args.push("-d");
+      args.push(...packages);
+      break;
+    case "npm":
+    default:
+      args.push("install");
+      if (isDev) args.push("--save-dev");
+      args.push(...packages);
+      break;
+  }
+  return args;
+}
+function buildRemoveArgs(pm, packages) {
+  const args = [];
+  switch (pm) {
+    case "pnpm":
+      args.push("remove", ...packages);
+      break;
+    case "yarn":
+      args.push("remove", ...packages);
+      break;
+    case "bun":
+      args.push("remove", ...packages);
+      break;
+    case "npm":
+    default:
+      args.push("uninstall", ...packages);
+      break;
+  }
+  return args;
+}
+function addDependencies(cwd, packages, isDev = false) {
+  if (packages.length === 0) {
+    return true;
+  }
+  const pm = detectPackageManager(cwd);
+  const args = buildInstallArgs(pm, packages, isDev);
+  try {
+    execFileSync(pm, args, {
+      cwd,
+      stdio: "pipe"
+    });
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to run ${pm} ${args.join(" ")}: ${message}`);
+    return false;
+  }
+}
+function removeDependencies(cwd, packages) {
+  if (packages.length === 0) {
+    return true;
+  }
+  const pm = detectPackageManager(cwd);
+  const args = buildRemoveArgs(pm, packages);
+  try {
+    execFileSync(pm, args, {
+      cwd,
+      stdio: "pipe"
+    });
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to run ${pm} ${args.join(" ")}: ${message}`);
+    return false;
+  }
+}
+
+// src/commands/config.ts
+var VALID_RENDERERS = ["react", "hono-jsx", "preact"];
+function configGet(key) {
+  const cwd = process.cwd();
+  switch (key) {
+    case "renderer": {
+      const config = readCloudwerkConfig(cwd);
+      const tsconfig = readTsConfig(cwd);
+      if (config.renderer) {
+        console.log(config.renderer);
+      } else if (tsconfig.jsxImportSource) {
+        const jsxSource = tsconfig.jsxImportSource;
+        if (jsxSource === "react") {
+          console.log("react");
+        } else if (jsxSource === "hono/jsx") {
+          console.log("hono-jsx");
+        } else if (jsxSource === "preact") {
+          console.log("preact");
+        } else {
+          console.log(pc2.yellow("unknown") + pc2.dim(` (jsxImportSource: ${jsxSource})`));
+        }
+      } else {
+        console.log("hono-jsx" + pc2.dim(" (default)"));
+      }
+      break;
+    }
+    default:
+      console.log(pc2.red(`Error: Unknown config key '${key}'`));
+      console.log();
+      console.log(pc2.dim("Available keys:"));
+      console.log(pc2.dim("  - renderer"));
+      process.exit(1);
+  }
+}
+async function configSet(key, value) {
+  const cwd = process.cwd();
+  switch (key) {
+    case "renderer": {
+      await setRenderer(cwd, value);
+      break;
+    }
+    default:
+      console.log(pc2.red(`Error: Unknown config key '${key}'`));
+      console.log();
+      console.log(pc2.dim("Available keys:"));
+      console.log(pc2.dim("  - renderer"));
+      process.exit(1);
+  }
+}
+async function setRenderer(cwd, renderer) {
+  if (!VALID_RENDERERS.includes(renderer)) {
+    console.log(pc2.red(`Error: Invalid renderer '${renderer}'`));
+    console.log();
+    console.log(pc2.dim("Valid renderers:"));
+    console.log(pc2.dim("  - react"));
+    console.log(pc2.dim("  - hono-jsx"));
+    console.log(pc2.dim("  - preact (limited support)"));
+    process.exit(1);
+  }
+  const rendererType = renderer;
+  if (rendererType === "preact") {
+    console.log(pc2.yellow("Warning: Preact renderer is not fully implemented yet."));
+    console.log(pc2.yellow("Only configuration will be updated."));
+    console.log();
+  }
+  const currentConfig = readCloudwerkConfig(cwd);
+  if (currentConfig.renderer === rendererType) {
+    console.log(pc2.yellow(`Renderer is already set to '${rendererType}'`));
+    return;
+  }
+  console.log();
+  if (rendererType === "react") {
+    await switchToReact(cwd);
+  } else if (rendererType === "hono-jsx") {
+    await switchToHonoJsx(cwd);
+  } else if (rendererType === "preact") {
+    await switchToPreact(cwd);
+  }
+}
+async function switchToReact(cwd) {
+  writeCloudwerkConfig(cwd, { renderer: "react" });
+  console.log(pc2.green("\u2713") + " Updated cloudwerk.config.ts");
+  const tsconfigUpdated = updateTsConfig(cwd, { jsxImportSource: "react" });
+  if (tsconfigUpdated) {
+    console.log(pc2.green("\u2713") + " Updated tsconfig.json " + pc2.dim("(jsxImportSource: react)"));
+  } else {
+    console.log(pc2.yellow("\u26A0") + " tsconfig.json not found, skipping");
+  }
+  console.log(pc2.cyan("\u2713") + " Installing dependencies...");
+  const { hasReact, hasReactDom, hasTypes } = hasReactDependencies(cwd);
+  const runtimeDeps = [];
+  if (!hasReact) runtimeDeps.push("react");
+  if (!hasReactDom) runtimeDeps.push("react-dom");
+  if (runtimeDeps.length > 0) {
+    const success = addDependencies(cwd, runtimeDeps, false);
+    if (success) {
+      console.log(pc2.green("\u2713") + " Added " + runtimeDeps.join(", "));
+    } else {
+      console.log(pc2.red("\u2717") + " Failed to install " + runtimeDeps.join(", "));
+    }
+  }
+  if (!hasTypes) {
+    const typesDeps = ["@types/react", "@types/react-dom"];
+    const success = addDependencies(cwd, typesDeps, true);
+    if (success) {
+      console.log(pc2.green("\u2713") + " Added " + typesDeps.join(", ") + pc2.dim(" (dev)"));
+    } else {
+      console.log(pc2.red("\u2717") + " Failed to install type definitions");
+    }
+  }
+  console.log();
+  console.log(pc2.green(pc2.bold("Renderer switched to React.")));
+  console.log();
+  console.log(pc2.dim("Note: Most Hono JSX code works with React unchanged."));
+  console.log(pc2.dim("See migration guide: https://cloudwerk.dev/docs/migration"));
+  console.log();
+}
+async function switchToHonoJsx(cwd) {
+  const incompatibleLibs = detectIncompatibleReactLibs(cwd);
+  if (incompatibleLibs.length > 0) {
+    console.log(pc2.yellow("\u26A0") + " " + pc2.bold("Compatibility warnings:"));
+    console.log();
+    console.log(pc2.dim("  The following dependencies may not work with Hono JSX:"));
+    console.log();
+    for (const lib of incompatibleLibs) {
+      console.log(pc2.yellow("  - ") + lib + pc2.dim(" (uses React internals)"));
+    }
+    console.log();
+    console.log(pc2.dim("  Consider keeping the React renderer or finding alternatives."));
+    console.log();
+    const proceed = await askConfirmation("Continue anyway?", false);
+    if (!proceed) {
+      console.log(pc2.dim("Aborted."));
+      return;
+    }
+    console.log();
+  }
+  writeCloudwerkConfig(cwd, { renderer: "hono-jsx" });
+  console.log(pc2.green("\u2713") + " Updated cloudwerk.config.ts");
+  const tsconfigUpdated = updateTsConfig(cwd, { jsxImportSource: "hono/jsx" });
+  if (tsconfigUpdated) {
+    console.log(pc2.green("\u2713") + " Updated tsconfig.json " + pc2.dim("(jsxImportSource: hono/jsx)"));
+  } else {
+    console.log(pc2.yellow("\u26A0") + " tsconfig.json not found, skipping");
+  }
+  const { installedPackages } = hasReactDependencies(cwd);
+  if (installedPackages.length > 0) {
+    console.log();
+    const removeReact = await askConfirmation("Remove React dependencies?", false);
+    if (removeReact) {
+      const success = removeDependencies(cwd, installedPackages);
+      if (success) {
+        console.log(pc2.green("\u2713") + " Removed " + installedPackages.join(", "));
+      } else {
+        console.log(pc2.red("\u2717") + " Failed to remove React dependencies");
+      }
+    }
+  }
+  console.log();
+  console.log(pc2.green(pc2.bold("Renderer switched to Hono JSX.")));
+  console.log();
+  console.log(pc2.bold("Benefits:"));
+  console.log(pc2.dim("- Smaller bundle size (~3kb vs ~45kb)"));
+  console.log(pc2.dim("- Workers-optimized"));
+  console.log(pc2.dim("- No external dependencies"));
+  console.log();
+  if (incompatibleLibs.length > 0) {
+    console.log(pc2.bold("Potential issues:"));
+    console.log(pc2.dim("- React-specific libraries won't work"));
+    console.log(pc2.dim("- Some Context API differences"));
+    console.log(pc2.dim("- forwardRef pattern may differ"));
+    console.log();
+  }
+  console.log(pc2.dim("See migration guide: https://cloudwerk.dev/docs/migration"));
+  console.log();
+}
+async function switchToPreact(cwd) {
+  writeCloudwerkConfig(cwd, { renderer: "preact" });
+  console.log(pc2.green("\u2713") + " Updated cloudwerk.config.ts");
+  const tsconfigUpdated = updateTsConfig(cwd, { jsxImportSource: "preact" });
+  if (tsconfigUpdated) {
+    console.log(pc2.green("\u2713") + " Updated tsconfig.json " + pc2.dim("(jsxImportSource: preact)"));
+  } else {
+    console.log(pc2.yellow("\u26A0") + " tsconfig.json not found, skipping");
+  }
+  console.log();
+  console.log(pc2.yellow(pc2.bold("Preact configuration applied.")));
+  console.log();
+  console.log(pc2.yellow("Note: Full Preact support is coming in a future release."));
+  console.log(pc2.yellow("You may need to manually install preact:"));
+  console.log(pc2.dim("  pnpm add preact"));
+  console.log();
+}
+async function askConfirmation(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultValue ? "Y/n" : "y/N";
+  return new Promise((resolve3) => {
+    rl.question(pc2.cyan("? ") + question + pc2.dim(` (${hint}) `), (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve3(defaultValue);
+      } else if (normalized === "y" || normalized === "yes") {
+        resolve3(true);
+      } else {
+        resolve3(false);
+      }
+    });
+  });
+}
+
 // src/index.ts
 program.name("cloudwerk").description("Cloudwerk CLI - Build and deploy full-stack apps to Cloudflare").version(VERSION);
 program.command("dev [path]").description("Start development server").option("-p, --port <number>", "Port to listen on", String(DEFAULT_PORT)).option("-H, --host <host>", "Host to bind", DEFAULT_HOST).option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(dev);
+program.command("build [path]").description("Build project for production").option("-o, --output <dir>", "Output directory", "./dist").option("--ssg", "Generate static pages for routes with rendering: static").option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(build9);
+var configCmd = program.command("config").description("Manage Cloudwerk configuration");
+configCmd.command("get <key>").description("Get a configuration value").action(configGet);
+configCmd.command("set <key> <value>").description("Set a configuration value").action(configSet);
 program.parse();