@cloudwerk/cli 0.1.1 → 0.2.1

package/dist/index.js

@@ -4,8 +4,8 @@
 import { program } from "commander";
 
 // src/commands/dev.ts
-import * as path6 from "path";
-import * as fs5 from "fs";
+import * as path8 from "path";
+import * as fs7 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, path7, status, duration) {
+function logRequest(method, path9, 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("]") + " " + path7 + " " + statusColor(String(status)) + " " + pc.dim(`${duration}ms`)
+    pc.dim("[") + methodColor(method.padEnd(6)) + pc.dim("]") + " " + path9 + " " + 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 = (path7) => {
-  const paths = path7.split("/");
+var splitPath = (path9) => {
+  const paths = path9.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path7 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path7);
+  const { groups, path: path9 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path9);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path7) => {
+var extractGroupsFromPath = (path9) => {
   const groups = [];
-  path7 = path7.replace(/\{[^}]+\}/g, (match2, index) => {
+  path9 = path9.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path7 };
+  return { groups, path: path9 };
 };
 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 path7 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path7.includes("%25") ? path7.replace(/%25/g, "%2525") : path7);
+      const path9 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
     } 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 = (path7) => {
-  if (path7.charCodeAt(path7.length - 1) !== 63 || !path7.includes(":")) {
+var checkOptionalParameter = (path9) => {
+  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) {
     return null;
   }
-  const segments = path7.split("/");
+  const segments = path9.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -474,9 +474,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path7 = "/", matchResult = [[]]) {
+  constructor(request, path9 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path7;
+    this.path = path9;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1212,8 +1212,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path7, ...handlers) => {
-      for (const p of [path7].flat()) {
+    this.on = (method, path9, ...handlers) => {
+      for (const p of [path9].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(path7, app) {
-    const subApp = this.basePath(path7);
+  route(path9, app) {
+    const subApp = this.basePath(path9);
     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(path7) {
+  basePath(path9) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path7);
+    subApp._basePath = mergePath(this._basePath, path9);
     return subApp;
   }
   /**
@@ -1373,7 +1373,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path7, applicationHandler, options) {
+  mount(path9, 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, path7);
+      const mergedPath = mergePath(this._basePath, path9);
       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(path7, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path9, "*"), handler);
     return this;
   }
-  #addRoute(method, path7, handler) {
+  #addRoute(method, path9, handler) {
     method = method.toUpperCase();
-    path7 = mergePath(this._basePath, path7);
-    const r = { basePath: this._basePath, path: path7, method, handler };
-    this.router.add(method, path7, [handler, r]);
+    path9 = mergePath(this._basePath, path9);
+    const r = { basePath: this._basePath, path: path9, method, handler };
+    this.router.add(method, path9, [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 path7 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path7);
+    const path9 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path9);
     const c = new Context(request, {
-      path: path7,
+      path: path9,
       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, path7) {
+function match(method, path9) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -1554,7 +1554,7 @@ function match(method, path7) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path7);
+  return match2(method, path9);
 }
 
 // ../../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(path7, index, pathErrorCheckOnly) {
+  insert(path9, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path7 = path7.replace(/\{[^}]+\}/g, (m) => {
+      path9 = path9.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -1685,7 +1685,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path7.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path9.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(path7) {
-  return wildcardRegExpCache[path7] ??= new RegExp(
-    path7 === "*" ? "" : `^${path7.replace(
+function buildWildcardRegExp(path9) {
+  return wildcardRegExpCache[path9] ??= new RegExp(
+    path9 === "*" ? "" : `^${path9.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, path7, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path9, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path7] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path9] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path7, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path9, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path7) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -1792,12 +1792,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path7) {
+function findMiddleware(middleware, path9) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path7)) {
+    if (buildWildcardRegExp(k).test(path9)) {
       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, path7, handler) {
+  add(method, path9, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -1826,18 +1826,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path7 === "/*") {
-      path7 = "*";
+    if (path9 === "/*") {
+      path9 = "*";
     }
-    const paramCount = (path7.match(/\/:/g) || []).length;
-    if (/\*$/.test(path7)) {
-      const re = buildWildcardRegExp(path7);
+    const paramCount = (path9.match(/\/:/g) || []).length;
+    if (/\*$/.test(path9)) {
+      const re = buildWildcardRegExp(path9);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path7] ||= findMiddleware(middleware[m], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
+          middleware[m][path9] ||= findMiddleware(middleware[m], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
         });
       } else {
-        middleware[method][path7] ||= findMiddleware(middleware[method], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
+        middleware[method][path9] ||= findMiddleware(middleware[method], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -1855,7 +1855,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path7) || [path7];
+    const paths = checkOptionalParameter(path9) || [path9];
     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((path7) => [path7, r[method][path7]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path9) => [path9, r[method][path9]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path7) => [path7, r[METHOD_NAME_ALL][path7]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path9) => [path9, r[METHOD_NAME_ALL][path9]])
         );
       }
     });
@@ -1908,13 +1908,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path7, handler) {
+  add(method, path9, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path7, handler]);
+    this.#routes.push([method, path9, handler]);
   }
-  match(method, path7) {
+  match(method, path9) {
     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, path7);
+        res = router.match(method, path9);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -1973,10 +1973,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path7, handler) {
+  insert(method, path9, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path7);
+    const parts = splitRoutingPath(path9);
     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, path7) {
+  search(method, path9) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path7);
+    const parts = splitPath(path9);
     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, path7, handler) {
-    const results = checkOptionalParameter(path7);
+  add(method, path9, handler) {
+    const results = checkOptionalParameter(path9);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path7, handler);
+    this.#node.insert(method, path9, handler);
   }
-  match(method, path7) {
-    return this.#node.search(method, path7);
+  match(method, path9) {
+    return this.#node.search(method, path9);
   }
 };
 
@@ -2155,8 +2155,15 @@ 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 * as path7 from "path";
+import {
+  createHandlerAdapter,
+  setRouteConfig,
+  NotFoundError,
+  RedirectError,
+  resolveErrorBoundary,
+  resolveNotFoundBoundary
+} from "@cloudwerk/core";
 import { render } from "@cloudwerk/ui";
 
 // src/server/loadHandler.ts
@@ -2406,10 +2413,33 @@ async function loadPageModule(absolutePath, verbose = false) {
         }
         validatedLoader = rawModule.loader;
       }
+      let validatedAction = void 0;
+      if ("action" in rawModule && rawModule.action !== void 0) {
+        if (typeof rawModule.action !== "function") {
+          throw new Error(
+            `Page action export must be a function, got ${typeof rawModule.action}`
+          );
+        }
+        validatedAction = rawModule.action;
+      }
+      const actionMethods = ["POST", "PUT", "PATCH", "DELETE"];
+      const validatedMethods = {};
+      for (const method of actionMethods) {
+        if (method in rawModule && rawModule[method] !== void 0) {
+          if (typeof rawModule[method] !== "function") {
+            throw new Error(
+              `Page ${method} export must be a function, got ${typeof rawModule[method]}`
+            );
+          }
+          validatedMethods[method] = rawModule[method];
+        }
+      }
       const module = {
         default: rawModule.default,
         config: validatedConfig,
-        loader: validatedLoader
+        loader: validatedLoader,
+        action: validatedAction,
+        ...validatedMethods
       };
       pageModuleCache.set(absolutePath, { module, mtime });
       return module;
@@ -2535,6 +2565,202 @@ function findSafeTempDir4(filePath) {
   return dir;
 }
 
+// src/server/loadErrorBoundary.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { builtinModules as builtinModules5 } from "module";
+import { build as build5 } from "esbuild";
+import { pathToFileURL as pathToFileURL5 } from "url";
+var errorBoundaryModuleCache = /* @__PURE__ */ new Map();
+async function loadErrorBoundaryModule(absolutePath, verbose = false) {
+  try {
+    const stat = fs5.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = errorBoundaryModuleCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return cached.module;
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build5({
+      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
+        ...builtinModules5,
+        ...builtinModules5.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 = findSafeTempDir5(absolutePath);
+    const tempFile = path5.join(tempDir, `.cloudwerk-error-${cacheKey}.mjs`);
+    fs5.writeFileSync(tempFile, code);
+    try {
+      const rawModule = await import(pathToFileURL5(tempFile).href);
+      if (!rawModule.default) {
+        throw new Error("Error boundary must have a default export");
+      }
+      if (typeof rawModule.default !== "function") {
+        throw new Error(
+          `Error boundary 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(
+            `Error boundary loader export must be a function, got ${typeof rawModule.loader}`
+          );
+        }
+        validatedLoader = rawModule.loader;
+      }
+      const module = {
+        default: rawModule.default,
+        loader: validatedLoader
+      };
+      errorBoundaryModuleCache.set(absolutePath, { module, mtime });
+      return module;
+    } finally {
+      try {
+        fs5.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile error boundary at ${absolutePath}: ${message}`);
+  }
+}
+function findSafeTempDir5(filePath) {
+  let dir = path5.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path5.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path5.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
+// src/server/loadNotFound.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { builtinModules as builtinModules6 } from "module";
+import { build as build6 } from "esbuild";
+import { pathToFileURL as pathToFileURL6 } from "url";
+var notFoundModuleCache = /* @__PURE__ */ new Map();
+async function loadNotFoundModule(absolutePath, verbose = false) {
+  try {
+    const stat = fs6.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = notFoundModuleCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return cached.module;
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build6({
+      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
+        ...builtinModules6,
+        ...builtinModules6.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 = findSafeTempDir6(absolutePath);
+    const tempFile = path6.join(tempDir, `.cloudwerk-not-found-${cacheKey}.mjs`);
+    fs6.writeFileSync(tempFile, code);
+    try {
+      const rawModule = await import(pathToFileURL6(tempFile).href);
+      if (!rawModule.default) {
+        throw new Error("Not-found boundary must have a default export");
+      }
+      if (typeof rawModule.default !== "function") {
+        throw new Error(
+          `Not-found boundary 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(
+            `Not-found boundary loader export must be a function, got ${typeof rawModule.loader}`
+          );
+        }
+        validatedLoader = rawModule.loader;
+      }
+      const module = {
+        default: rawModule.default,
+        loader: validatedLoader
+      };
+      notFoundModuleCache.set(absolutePath, { module, mtime });
+      return module;
+    } finally {
+      try {
+        fs6.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile not-found boundary at ${absolutePath}: ${message}`);
+  }
+}
+function findSafeTempDir6(filePath) {
+  let dir = path6.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path6.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path6.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
 // src/server/parseSearchParams.ts
 function parseSearchParams(c) {
   const result = {};
@@ -2574,16 +2800,27 @@ async function executeLoader(loader, args, c) {
     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 executeAction(action, args, c) {
+  try {
+    const result = await Promise.resolve(action(args));
+    if (result instanceof Response) {
+      return { response: result };
+    }
+    return { data: result ?? {} };
+  } catch (error) {
     if (error instanceof RedirectError) {
       return { response: c.redirect(error.url, error.status) };
     }
     throw error;
   }
 }
-async function registerRoutes(app, manifest, logger, verbose = false) {
+async function registerRoutes(app, manifest, scanResult, logger, verbose = false) {
   const registeredRoutes = [];
   for (const route of manifest.routes) {
     if (route.fileType === "page") {
@@ -2601,7 +2838,7 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
             app.use(route.urlPattern, middlewareHandler);
             if (verbose) {
               logger.info(
-                `Applied middleware: ${path5.basename(middlewarePath)} -> ${route.urlPattern}`
+                `Applied middleware: ${path7.basename(middlewarePath)} -> ${route.urlPattern}`
               );
             }
           }
@@ -2613,12 +2850,12 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
           }
         }
         app.get(route.urlPattern, async (c) => {
+          const params = c.req.param();
+          const searchParams = parseSearchParams(c);
+          const request = c.req.raw;
+          const layoutLoaderData = [];
           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) {
@@ -2652,6 +2889,67 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
             }
             return render(element);
           } catch (error) {
+            if (error instanceof NotFoundError) {
+              const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
+              if (notFoundPath) {
+                try {
+                  const notFoundModule = await loadNotFoundModule(notFoundPath, verbose);
+                  const NotFoundComponent = notFoundModule.default;
+                  const notFoundProps = { params, searchParams };
+                  let notFoundElement = await Promise.resolve(NotFoundComponent(notFoundProps));
+                  for (let i = layouts.length - 1; i >= 0; i--) {
+                    const Layout = layouts[i];
+                    const layoutProps = {
+                      children: notFoundElement,
+                      params,
+                      ...layoutLoaderData[i]
+                    };
+                    notFoundElement = await Promise.resolve(Layout(layoutProps));
+                  }
+                  return render(notFoundElement, { status: 404 });
+                } catch (boundaryError) {
+                  const boundaryMessage = boundaryError instanceof Error ? boundaryError.message : String(boundaryError);
+                  logger.error(`Not-found boundary failed: ${boundaryMessage}`);
+                }
+              }
+              return c.notFound();
+            }
+            const errorPath = resolveErrorBoundary(route.filePath, scanResult.errors);
+            if (errorPath) {
+              try {
+                const errorModule = await loadErrorBoundaryModule(errorPath, verbose);
+                const ErrorComponent = errorModule.default;
+                const digest = crypto.randomUUID().slice(0, 8);
+                const originalMessage = error instanceof Error ? error.message : String(error);
+                logger.error(`Error [${digest}] in ${route.filePath}: ${originalMessage}`);
+                const sanitizedError = process.env.NODE_ENV === "production" ? Object.assign(new Error("An error occurred"), { digest }) : Object.assign(
+                  error instanceof Error ? error : new Error(String(error)),
+                  { digest }
+                );
+                const errorProps = {
+                  error: sanitizedError,
+                  errorType: "loader",
+                  reset: () => {
+                  },
+                  params,
+                  searchParams
+                };
+                let errorElement = await Promise.resolve(ErrorComponent(errorProps));
+                for (let i = layouts.length - 1; i >= 0; i--) {
+                  const Layout = layouts[i];
+                  const layoutProps = {
+                    children: errorElement,
+                    params,
+                    ...layoutLoaderData[i]
+                  };
+                  errorElement = await Promise.resolve(Layout(layoutProps));
+                }
+                return render(errorElement, { status: 500 });
+              } catch (boundaryError) {
+                const boundaryMessage = boundaryError instanceof Error ? boundaryError.message : String(boundaryError);
+                logger.error(`Error boundary failed: ${boundaryMessage}`);
+              }
+            }
             const message = error instanceof Error ? error.message : String(error);
             logger.error(`Error rendering page ${route.filePath}: ${message}`);
             return c.html(
@@ -2666,6 +2964,138 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
           filePath: route.filePath
         });
         logger.debug(`Registered page ${route.urlPattern}`);
+        const actionMethods = ["POST", "PUT", "PATCH", "DELETE"];
+        for (const method of actionMethods) {
+          const action = pageModule[method] ?? pageModule.action;
+          if (action && typeof action === "function") {
+            const actionFn = action;
+            registerMethod(app, method, route.urlPattern, async (c) => {
+              const params = c.req.param();
+              const searchParams = parseSearchParams(c);
+              const request = c.req.raw;
+              const layoutLoaderData = [];
+              try {
+                const actionArgs = { params, request, context: c };
+                const actionResult = await executeAction(actionFn, actionArgs, c);
+                if (actionResult.response) {
+                  return actionResult.response;
+                }
+                const loaderArgs = { params, request, context: c };
+                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,
+                  actionData: actionResult.data,
+                  ...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) {
+                if (error instanceof NotFoundError) {
+                  const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
+                  if (notFoundPath) {
+                    try {
+                      const notFoundModule = await loadNotFoundModule(notFoundPath, verbose);
+                      const NotFoundComponent = notFoundModule.default;
+                      const notFoundProps = { params, searchParams };
+                      let notFoundElement = await Promise.resolve(NotFoundComponent(notFoundProps));
+                      for (let i = layouts.length - 1; i >= 0; i--) {
+                        const Layout = layouts[i];
+                        const layoutProps = {
+                          children: notFoundElement,
+                          params,
+                          ...layoutLoaderData[i]
+                        };
+                        notFoundElement = await Promise.resolve(Layout(layoutProps));
+                      }
+                      return render(notFoundElement, { status: 404 });
+                    } catch (boundaryError) {
+                      const boundaryMessage = boundaryError instanceof Error ? boundaryError.message : String(boundaryError);
+                      logger.error(`Not-found boundary failed: ${boundaryMessage}`);
+                    }
+                  }
+                  return c.notFound();
+                }
+                const errorPath = resolveErrorBoundary(route.filePath, scanResult.errors);
+                if (errorPath) {
+                  try {
+                    const errorModule = await loadErrorBoundaryModule(errorPath, verbose);
+                    const ErrorComponent = errorModule.default;
+                    const digest = crypto.randomUUID().slice(0, 8);
+                    const originalMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`Error [${digest}] in ${route.filePath} action: ${originalMessage}`);
+                    const sanitizedError = process.env.NODE_ENV === "production" ? Object.assign(new Error("An error occurred"), { digest }) : Object.assign(
+                      error instanceof Error ? error : new Error(String(error)),
+                      { digest }
+                    );
+                    const errorProps = {
+                      error: sanitizedError,
+                      errorType: "action",
+                      reset: () => {
+                      },
+                      params,
+                      searchParams
+                    };
+                    let errorElement = await Promise.resolve(ErrorComponent(errorProps));
+                    for (let i = layouts.length - 1; i >= 0; i--) {
+                      const Layout = layouts[i];
+                      const layoutProps = {
+                        children: errorElement,
+                        params,
+                        ...layoutLoaderData[i]
+                      };
+                      errorElement = await Promise.resolve(Layout(layoutProps));
+                    }
+                    return render(errorElement, { status: 500 });
+                  } catch (boundaryError) {
+                    const boundaryMessage = boundaryError instanceof Error ? boundaryError.message : String(boundaryError);
+                    logger.error(`Error boundary failed: ${boundaryMessage}`);
+                  }
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                logger.error(`Error executing action ${route.filePath}: ${message}`);
+                return c.html(
+                  `<!DOCTYPE html><html><body><h1>Internal Server Error</h1></body></html>`,
+                  500
+                );
+              }
+            });
+            registeredRoutes.push({
+              method,
+              pattern: route.urlPattern,
+              filePath: route.filePath
+            });
+            logger.debug(`Registered ${method} action ${route.urlPattern}`);
+          }
+        }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logger.error(`Failed to load page ${route.filePath}: ${message}`);
@@ -2682,7 +3112,7 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
         if (middlewareHandler) {
           app.use(route.urlPattern, middlewareHandler);
           if (verbose) {
-            logger.info(`Applied middleware: ${path5.basename(middlewarePath)} -> ${route.urlPattern}`);
+            logger.info(`Applied middleware: ${path7.basename(middlewarePath)} -> ${route.urlPattern}`);
           }
         }
       }
@@ -2750,7 +3180,7 @@ var HTTP_STATUS = {
 };
 
 // src/server/createApp.ts
-async function createApp(manifest, config, logger, verbose = false) {
+async function createApp(manifest, scanResult, config, logger, verbose = false) {
   const rendererName = config.ui?.renderer ?? "hono-jsx";
   try {
     setActiveRenderer(rendererName);
@@ -2781,7 +3211,7 @@ async function createApp(manifest, config, logger, verbose = false) {
       app.use("*", middleware);
     }
   }
-  const routes = await registerRoutes(app, manifest, logger, verbose);
+  const routes = await registerRoutes(app, manifest, scanResult, logger, verbose);
   app.notFound((c) => {
     return c.json(
       {
@@ -2818,8 +3248,8 @@ async function dev(pathArg, options) {
   const verbose = options.verbose ?? false;
   const logger = createLogger(verbose);
   try {
-    const cwd = pathArg ? path6.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs5.existsSync(cwd)) {
+    const cwd = pathArg ? path8.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs7.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -2832,7 +3262,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 (!fs5.existsSync(routesDir)) {
+    if (!fs7.existsSync(routesDir)) {
       throw new CliError(
         `Routes directory does not exist: ${routesDir}`,
         "ENOENT",
@@ -2867,7 +3297,7 @@ async function dev(pathArg, options) {
       logger.warn(`Create a route.ts file to get started.`);
     }
     logger.debug(`Creating Hono app...`);
-    const { app, routes } = await createApp(manifest, config, logger, verbose);
+    const { app, routes } = await createApp(manifest, scanResult, config, logger, verbose);
     const port = parseInt(options.port, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
       throw new CliError(

package/package.json

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