@cloudwerk/cli 0.0.6 → 0.1.1

package/dist/index.js

@@ -4,8 +4,8 @@
 import { program } from "commander";
 
 // src/commands/dev.ts
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path6 from "path";
+import * as fs5 from "fs";
 import * as os from "os";
 import { serve } from "@hono/node-server";
 import {
@@ -112,11 +112,11 @@ function printError(message, suggestion) {
   }
   console.log();
 }
-function logRequest(method, path3, status, duration) {
+function logRequest(method, path7, 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("]") + " " + path3 + " " + statusColor(String(status)) + " " + pc.dim(`${duration}ms`)
+    pc.dim("[") + methodColor(method.padEnd(6)) + pc.dim("]") + " " + path7 + " " + 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 = (path3) => {
-  const paths = path3.split("/");
+var splitPath = (path7) => {
+  const paths = path7.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path3 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path3);
+  const { groups, path: path7 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path7);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path3) => {
+var extractGroupsFromPath = (path7) => {
   const groups = [];
-  path3 = path3.replace(/\{[^}]+\}/g, (match2, index) => {
+  path7 = path7.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path3 };
+  return { groups, path: path7 };
 };
 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 path3 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path3.includes("%25") ? path3.replace(/%25/g, "%2525") : path3);
+      const path7 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path7.includes("%25") ? path7.replace(/%25/g, "%2525") : path7);
     } 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 = (path3) => {
-  if (path3.charCodeAt(path3.length - 1) !== 63 || !path3.includes(":")) {
+var checkOptionalParameter = (path7) => {
+  if (path7.charCodeAt(path7.length - 1) !== 63 || !path7.includes(":")) {
     return null;
   }
-  const segments = path3.split("/");
+  const segments = path7.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -474,9 +474,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path3 = "/", matchResult = [[]]) {
+  constructor(request, path7 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path3;
+    this.path = path7;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1212,8 +1212,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path3, ...handlers) => {
-      for (const p of [path3].flat()) {
+    this.on = (method, path7, ...handlers) => {
+      for (const p of [path7].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(path3, app) {
-    const subApp = this.basePath(path3);
+  route(path7, app) {
+    const subApp = this.basePath(path7);
     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(path3) {
+  basePath(path7) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path3);
+    subApp._basePath = mergePath(this._basePath, path7);
     return subApp;
   }
   /**
@@ -1373,7 +1373,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path3, applicationHandler, options) {
+  mount(path7, 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, path3);
+      const mergedPath = mergePath(this._basePath, path7);
       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(path3, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path7, "*"), handler);
     return this;
   }
-  #addRoute(method, path3, handler) {
+  #addRoute(method, path7, handler) {
     method = method.toUpperCase();
-    path3 = mergePath(this._basePath, path3);
-    const r = { basePath: this._basePath, path: path3, method, handler };
-    this.router.add(method, path3, [handler, r]);
+    path7 = mergePath(this._basePath, path7);
+    const r = { basePath: this._basePath, path: path7, method, handler };
+    this.router.add(method, path7, [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 path3 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path3);
+    const path7 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path7);
     const c = new Context(request, {
-      path: path3,
+      path: path7,
       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, path3) {
+function match(method, path7) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -1554,7 +1554,7 @@ function match(method, path3) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path3);
+  return match2(method, path7);
 }
 
 // ../../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(path3, index, pathErrorCheckOnly) {
+  insert(path7, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path3 = path3.replace(/\{[^}]+\}/g, (m) => {
+      path7 = path7.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -1685,7 +1685,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path3.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path7.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(path3) {
-  return wildcardRegExpCache[path3] ??= new RegExp(
-    path3 === "*" ? "" : `^${path3.replace(
+function buildWildcardRegExp(path7) {
+  return wildcardRegExpCache[path7] ??= new RegExp(
+    path7 === "*" ? "" : `^${path7.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, path3, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path7, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path3] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path7] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path3, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path7, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path3) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path7) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -1792,12 +1792,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path3) {
+function findMiddleware(middleware, path7) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path3)) {
+    if (buildWildcardRegExp(k).test(path7)) {
       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, path3, handler) {
+  add(method, path7, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -1826,18 +1826,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path3 === "/*") {
-      path3 = "*";
+    if (path7 === "/*") {
+      path7 = "*";
     }
-    const paramCount = (path3.match(/\/:/g) || []).length;
-    if (/\*$/.test(path3)) {
-      const re = buildWildcardRegExp(path3);
+    const paramCount = (path7.match(/\/:/g) || []).length;
+    if (/\*$/.test(path7)) {
+      const re = buildWildcardRegExp(path7);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path3] ||= findMiddleware(middleware[m], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
+          middleware[m][path7] ||= findMiddleware(middleware[m], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
         });
       } else {
-        middleware[method][path3] ||= findMiddleware(middleware[method], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
+        middleware[method][path7] ||= findMiddleware(middleware[method], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -1855,7 +1855,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path3) || [path3];
+    const paths = checkOptionalParameter(path7) || [path7];
     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((path3) => [path3, r[method][path3]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path7) => [path7, r[method][path7]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path3) => [path3, r[METHOD_NAME_ALL][path3]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path7) => [path7, r[METHOD_NAME_ALL][path7]])
         );
       }
     });
@@ -1908,13 +1908,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path3, handler) {
+  add(method, path7, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path3, handler]);
+    this.#routes.push([method, path7, handler]);
   }
-  match(method, path3) {
+  match(method, path7) {
     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, path3);
+        res = router.match(method, path7);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -1973,10 +1973,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path3, handler) {
+  insert(method, path7, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path3);
+    const parts = splitRoutingPath(path7);
     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, path3) {
+  search(method, path7) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path3);
+    const parts = splitPath(path7);
     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, path3, handler) {
-    const results = checkOptionalParameter(path3);
+  add(method, path7, handler) {
+    const results = checkOptionalParameter(path7);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path3, handler);
+    this.#node.insert(method, path7, handler);
   }
-  match(method, path3) {
-    return this.#node.search(method, path3);
+  match(method, path7) {
+    return this.#node.search(method, path7);
   }
 };
 
@@ -2150,12 +2150,22 @@ var Hono2 = class extends Hono {
   }
 };
 
+// src/server/createApp.ts
+import { contextMiddleware } from "@cloudwerk/core";
+import { setActiveRenderer, getAvailableRenderers } from "@cloudwerk/ui";
+
+// src/server/registerRoutes.ts
+import * as path5 from "path";
+import { createHandlerAdapter, setRouteConfig, NotFoundError, RedirectError } from "@cloudwerk/core";
+import { render } from "@cloudwerk/ui";
+
 // src/server/loadHandler.ts
 import * as fs from "fs";
 import * as path from "path";
 import { builtinModules } from "module";
 import { build } from "esbuild";
 import { pathToFileURL } from "url";
+import { validateRouteConfig } from "@cloudwerk/core";
 var moduleCache = /* @__PURE__ */ new Map();
 async function loadRouteHandler(absolutePath, verbose = false) {
   try {
@@ -2193,7 +2203,15 @@ async function loadRouteHandler(absolutePath, verbose = false) {
     const tempFile = path.join(tempDir, `.cloudwerk-route-${cacheKey}.mjs`);
     fs.writeFileSync(tempFile, code);
     try {
-      const module = await import(pathToFileURL(tempFile).href);
+      const rawModule = await import(pathToFileURL(tempFile).href);
+      let validatedConfig = void 0;
+      if ("config" in rawModule) {
+        validatedConfig = validateRouteConfig(rawModule.config, absolutePath);
+      }
+      const module = {
+        ...rawModule,
+        config: validatedConfig
+      };
       moduleCache.set(absolutePath, { module, mtime });
       return module;
     } finally {
@@ -2220,6 +2238,318 @@ function findSafeTempDir(filePath) {
   return dir;
 }
 
+// src/server/loadMiddleware.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { builtinModules as builtinModules2 } from "module";
+import { build as build2 } from "esbuild";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { createMiddlewareAdapter } from "@cloudwerk/core";
+var middlewareCache = /* @__PURE__ */ new Map();
+async function loadMiddlewareModule(absolutePath, verbose = false) {
+  if (!fs2.existsSync(absolutePath)) {
+    if (verbose) {
+      console.warn(`Middleware not found: ${absolutePath}`);
+    }
+    return null;
+  }
+  try {
+    const stat = fs2.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = middlewareCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return extractMiddleware(cached.module, absolutePath, verbose);
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build2({
+      entryPoints: [absolutePath],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      target,
+      external: [
+        "@cloudwerk/core",
+        "hono",
+        // Use builtinModules for comprehensive Node.js built-in coverage
+        ...builtinModules2,
+        ...builtinModules2.map((m) => `node:${m}`)
+      ],
+      logLevel: verbose ? "warning" : "silent",
+      sourcemap: "inline"
+    });
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+      throw new Error("No output from esbuild");
+    }
+    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const tempDir = findSafeTempDir2(absolutePath);
+    const tempFile = path2.join(tempDir, `.cloudwerk-middleware-${cacheKey}.mjs`);
+    fs2.writeFileSync(tempFile, result.outputFiles[0].text);
+    try {
+      const module = await import(pathToFileURL2(tempFile).href);
+      middlewareCache.set(absolutePath, { module, mtime });
+      return extractMiddleware(module, absolutePath, verbose);
+    } finally {
+      try {
+        fs2.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to compile middleware at ${absolutePath}: ${message}`);
+    return null;
+  }
+}
+function extractMiddleware(module, absolutePath, verbose) {
+  const middleware = module.default ?? module.middleware;
+  if (!middleware) {
+    if (verbose) {
+      console.warn(
+        `Middleware at ${absolutePath} must export a default function or named 'middleware' export`
+      );
+    }
+    return null;
+  }
+  if (typeof middleware !== "function") {
+    console.warn(
+      `Middleware in ${absolutePath} must export a function, got ${typeof middleware}`
+    );
+    return null;
+  }
+  return createMiddlewareAdapter(middleware);
+}
+function findSafeTempDir2(filePath) {
+  let dir = path2.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path2.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
+// src/server/loadPage.ts
+import * as fs3 from "fs";
+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";
+var pageModuleCache = /* @__PURE__ */ new Map();
+async function loadPageModule(absolutePath, verbose = false) {
+  try {
+    const stat = fs3.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = pageModuleCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return cached.module;
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build3({
+      entryPoints: [absolutePath],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      target,
+      jsx: "automatic",
+      jsxImportSource: "hono/jsx",
+      external: [
+        "@cloudwerk/core",
+        "@cloudwerk/ui",
+        "hono",
+        "hono/jsx",
+        "hono/jsx/dom",
+        "hono/jsx/streaming",
+        "hono/html",
+        // Use builtinModules for comprehensive Node.js built-in coverage
+        ...builtinModules3,
+        ...builtinModules3.map((m) => `node:${m}`)
+      ],
+      logLevel: verbose ? "warning" : "silent",
+      sourcemap: "inline"
+    });
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+      throw new Error("No output from esbuild");
+    }
+    const code = result.outputFiles[0].text;
+    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const tempDir = findSafeTempDir3(absolutePath);
+    const tempFile = path3.join(tempDir, `.cloudwerk-page-${cacheKey}.mjs`);
+    fs3.writeFileSync(tempFile, code);
+    try {
+      const rawModule = await import(pathToFileURL3(tempFile).href);
+      if (!rawModule.default) {
+        throw new Error("Page must have a default export");
+      }
+      if (typeof rawModule.default !== "function") {
+        throw new Error(
+          `Page default export must be a function (component), got ${typeof rawModule.default}`
+        );
+      }
+      let validatedConfig = void 0;
+      if ("config" in rawModule && rawModule.config !== void 0) {
+        validatedConfig = validateRouteConfig2(rawModule.config, absolutePath);
+      }
+      let validatedLoader = void 0;
+      if ("loader" in rawModule && rawModule.loader !== void 0) {
+        if (typeof rawModule.loader !== "function") {
+          throw new Error(
+            `Page loader export must be a function, got ${typeof rawModule.loader}`
+          );
+        }
+        validatedLoader = rawModule.loader;
+      }
+      const module = {
+        default: rawModule.default,
+        config: validatedConfig,
+        loader: validatedLoader
+      };
+      pageModuleCache.set(absolutePath, { module, mtime });
+      return module;
+    } finally {
+      try {
+        fs3.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile page at ${absolutePath}: ${message}`);
+  }
+}
+function findSafeTempDir3(filePath) {
+  let dir = path3.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path3.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path3.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
+// src/server/loadLayout.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { builtinModules as builtinModules4 } from "module";
+import { build as build4 } from "esbuild";
+import { pathToFileURL as pathToFileURL4 } from "url";
+var layoutModuleCache = /* @__PURE__ */ new Map();
+async function loadLayoutModule(absolutePath, verbose = false) {
+  try {
+    const stat = fs4.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = layoutModuleCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return cached.module;
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build4({
+      entryPoints: [absolutePath],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      target,
+      jsx: "automatic",
+      jsxImportSource: "hono/jsx",
+      external: [
+        "@cloudwerk/core",
+        "@cloudwerk/ui",
+        "hono",
+        "hono/jsx",
+        "hono/jsx/dom",
+        "hono/jsx/streaming",
+        "hono/html",
+        // Use builtinModules for comprehensive Node.js built-in coverage
+        ...builtinModules4,
+        ...builtinModules4.map((m) => `node:${m}`)
+      ],
+      logLevel: verbose ? "warning" : "silent",
+      sourcemap: "inline"
+    });
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+      throw new Error("No output from esbuild");
+    }
+    const code = result.outputFiles[0].text;
+    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const tempDir = findSafeTempDir4(absolutePath);
+    const tempFile = path4.join(tempDir, `.cloudwerk-layout-${cacheKey}.mjs`);
+    fs4.writeFileSync(tempFile, code);
+    try {
+      const rawModule = await import(pathToFileURL4(tempFile).href);
+      if (!rawModule.default) {
+        throw new Error("Layout must have a default export");
+      }
+      if (typeof rawModule.default !== "function") {
+        throw new Error(
+          `Layout default export must be a function (component), got ${typeof rawModule.default}`
+        );
+      }
+      let validatedLoader = void 0;
+      if ("loader" in rawModule && rawModule.loader !== void 0) {
+        if (typeof rawModule.loader !== "function") {
+          throw new Error(
+            `Layout loader export must be a function, got ${typeof rawModule.loader}`
+          );
+        }
+        validatedLoader = rawModule.loader;
+      }
+      const module = {
+        default: rawModule.default,
+        loader: validatedLoader
+      };
+      layoutModuleCache.set(absolutePath, { module, mtime });
+      return module;
+    } finally {
+      try {
+        fs4.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile layout at ${absolutePath}: ${message}`);
+  }
+}
+function findSafeTempDir4(filePath) {
+  let dir = path4.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path4.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path4.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
+// src/server/parseSearchParams.ts
+function parseSearchParams(c) {
+  const result = {};
+  const url = new URL(c.req.url);
+  for (const [key, value] of url.searchParams.entries()) {
+    const existing = result[key];
+    if (existing !== void 0) {
+      result[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 // src/server/registerRoutes.ts
 var HTTP_METHODS = [
   "GET",
@@ -2230,16 +2560,140 @@ var HTTP_METHODS = [
   "OPTIONS",
   "HEAD"
 ];
+function isCloudwerkHandler(fn) {
+  return typeof fn === "function" && fn.length === 2;
+}
+function createConfigMiddleware(config) {
+  return async (c, next) => {
+    setRouteConfig(config);
+    await next();
+  };
+}
+async function executeLoader(loader, args, c) {
+  try {
+    const data = await Promise.resolve(loader(args));
+    return { data: data ?? {} };
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      return { response: await Promise.resolve(c.notFound()) };
+    }
+    if (error instanceof RedirectError) {
+      return { response: c.redirect(error.url, error.status) };
+    }
+    throw error;
+  }
+}
 async function registerRoutes(app, manifest, logger, verbose = false) {
   const registeredRoutes = [];
   for (const route of manifest.routes) {
+    if (route.fileType === "page") {
+      try {
+        logger.debug(`Loading page: ${route.filePath}`);
+        const pageModule = await loadPageModule(route.absolutePath, verbose);
+        const PageComponent = pageModule.default;
+        const layoutModules = await Promise.all(
+          route.layouts.map((layoutPath) => loadLayoutModule(layoutPath, verbose))
+        );
+        const layouts = layoutModules.map((m) => m.default);
+        for (const middlewarePath of route.middleware) {
+          const middlewareHandler = await loadMiddlewareModule(middlewarePath, verbose);
+          if (middlewareHandler) {
+            app.use(route.urlPattern, middlewareHandler);
+            if (verbose) {
+              logger.info(
+                `Applied middleware: ${path5.basename(middlewarePath)} -> ${route.urlPattern}`
+              );
+            }
+          }
+        }
+        if (pageModule.config) {
+          app.use(route.urlPattern, createConfigMiddleware(pageModule.config));
+          if (verbose) {
+            logger.info(`Applied page config: ${route.filePath} -> ${route.urlPattern}`);
+          }
+        }
+        app.get(route.urlPattern, async (c) => {
+          try {
+            const params = c.req.param();
+            const searchParams = parseSearchParams(c);
+            const request = c.req.raw;
+            const loaderArgs = { params, request, context: c };
+            const layoutLoaderData = [];
+            for (let index = 0; index < layoutModules.length; index++) {
+              const layoutModule = layoutModules[index];
+              if (layoutModule.loader) {
+                const result = await executeLoader(layoutModule.loader, loaderArgs, c);
+                if (result.response) {
+                  return result.response;
+                }
+                layoutLoaderData[index] = result.data;
+              } else {
+                layoutLoaderData[index] = {};
+              }
+            }
+            let pageLoaderData = {};
+            if (pageModule.loader) {
+              const result = await executeLoader(pageModule.loader, loaderArgs, c);
+              if (result.response) {
+                return result.response;
+              }
+              pageLoaderData = result.data;
+            }
+            const pageProps = { params, searchParams, ...pageLoaderData };
+            let element = await Promise.resolve(PageComponent(pageProps));
+            for (let i = layouts.length - 1; i >= 0; i--) {
+              const Layout = layouts[i];
+              const layoutProps = {
+                children: element,
+                params,
+                ...layoutLoaderData[i]
+              };
+              element = await Promise.resolve(Layout(layoutProps));
+            }
+            return render(element);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Error rendering page ${route.filePath}: ${message}`);
+            return c.html(
+              `<!DOCTYPE html><html><body><h1>Internal Server Error</h1></body></html>`,
+              500
+            );
+          }
+        });
+        registeredRoutes.push({
+          method: "GET",
+          pattern: route.urlPattern,
+          filePath: route.filePath
+        });
+        logger.debug(`Registered page ${route.urlPattern}`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to load page ${route.filePath}: ${message}`);
+      }
+      continue;
+    }
     if (route.fileType !== "route") {
       logger.debug(`Skipping non-route file: ${route.filePath}`);
       continue;
     }
     try {
+      for (const middlewarePath of route.middleware) {
+        const middlewareHandler = await loadMiddlewareModule(middlewarePath, verbose);
+        if (middlewareHandler) {
+          app.use(route.urlPattern, middlewareHandler);
+          if (verbose) {
+            logger.info(`Applied middleware: ${path5.basename(middlewarePath)} -> ${route.urlPattern}`);
+          }
+        }
+      }
       logger.debug(`Loading route handler: ${route.filePath}`);
       const module = await loadRouteHandler(route.absolutePath, verbose);
+      if (module.config) {
+        app.use(route.urlPattern, createConfigMiddleware(module.config));
+        if (verbose) {
+          logger.info(`Applied route config: ${route.filePath} -> ${route.urlPattern}`);
+        }
+      }
       for (const method of HTTP_METHODS) {
         const handler = module[method];
         if (handler && typeof handler === "function") {
@@ -2260,7 +2714,7 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
   return registeredRoutes;
 }
 function registerMethod(app, method, pattern, handler) {
-  const h = handler;
+  const h = isCloudwerkHandler(handler) ? createHandlerAdapter(handler) : handler;
   switch (method) {
     case "GET":
       app.get(pattern, h);
@@ -2297,9 +2751,23 @@ var HTTP_STATUS = {
 
 // src/server/createApp.ts
 async function createApp(manifest, config, logger, verbose = false) {
+  const rendererName = config.ui?.renderer ?? "hono-jsx";
+  try {
+    setActiveRenderer(rendererName);
+    if (verbose) {
+      logger.info(`Using UI renderer: ${rendererName}`);
+    }
+  } catch (error) {
+    const available = getAvailableRenderers().join(", ");
+    throw new Error(
+      `Failed to initialize UI renderer "${rendererName}". Available renderers: ${available}.`,
+      { cause: error }
+    );
+  }
   const app = new Hono2({
     strict: false
   });
+  app.use("*", contextMiddleware());
   if (verbose) {
     app.use("*", async (c, next) => {
       const start = Date.now();
@@ -2350,8 +2818,8 @@ async function dev(pathArg, options) {
   const verbose = options.verbose ?? false;
   const logger = createLogger(verbose);
   try {
-    const cwd = pathArg ? path2.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs2.existsSync(cwd)) {
+    const cwd = pathArg ? path6.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs5.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -2364,7 +2832,7 @@ async function dev(pathArg, options) {
     logger.debug(`Config loaded: routesDir=${config.routesDir}, extensions=${config.extensions.join(", ")}`);
     const routesDir = resolveRoutesDir(config, cwd);
     logger.debug(`Routes directory: ${routesDir}`);
-    if (!fs2.existsSync(routesDir)) {
+    if (!fs5.existsSync(routesDir)) {
       throw new CliError(
         `Routes directory does not exist: ${routesDir}`,
         "ENOENT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/cli",
-  "version": "0.0.6",
+  "version": "0.1.1",
   "description": "Dev server, build, deploy commands for Cloudwerk",
   "repository": {
     "type": "git",
@@ -25,7 +25,8 @@
     "commander": "^12.1.0",
     "esbuild": "^0.25.0",
     "picocolors": "^1.1.0",
-    "@cloudwerk/core": "^0.0.6"
+    "@cloudwerk/core": "^0.1.1",
+    "@cloudwerk/ui": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",