@cloudwerk/cli 0.2.0 → 0.3.0

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 path9 from "path";
+import * as fs8 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, path10, 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("]") + " " + path10 + " " + 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 = (path10) => {
+  const paths = path10.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path7 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path7);
+  const { groups, path: path10 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path10);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path7) => {
+var extractGroupsFromPath = (path10) => {
   const groups = [];
-  path7 = path7.replace(/\{[^}]+\}/g, (match2, index) => {
+  path10 = path10.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path7 };
+  return { groups, path: path10 };
 };
 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 path10 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path10.includes("%25") ? path10.replace(/%25/g, "%2525") : path10);
     } 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 = (path10) => {
+  if (path10.charCodeAt(path10.length - 1) !== 63 || !path10.includes(":")) {
     return null;
   }
-  const segments = path7.split("/");
+  const segments = path10.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -474,9 +474,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path7 = "/", matchResult = [[]]) {
+  constructor(request, path10 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path7;
+    this.path = path10;
     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, path10, ...handlers) => {
+      for (const p of [path10].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(path10, app) {
+    const subApp = this.basePath(path10);
     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(path10) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path7);
+    subApp._basePath = mergePath(this._basePath, path10);
     return subApp;
   }
   /**
@@ -1373,7 +1373,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path7, applicationHandler, options) {
+  mount(path10, 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, path10);
       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(path10, "*"), handler);
     return this;
   }
-  #addRoute(method, path7, handler) {
+  #addRoute(method, path10, 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]);
+    path10 = mergePath(this._basePath, path10);
+    const r = { basePath: this._basePath, path: path10, method, handler };
+    this.router.add(method, path10, [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 path10 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path10);
     const c = new Context(request, {
-      path: path7,
+      path: path10,
       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, path10) {
   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, path10);
 }
 
 // ../../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(path10, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path7 = path7.replace(/\{[^}]+\}/g, (m) => {
+      path10 = path10.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 = path10.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(path10) {
+  return wildcardRegExpCache[path10] ??= new RegExp(
+    path10 === "*" ? "" : `^${path10.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, path10, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path7] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path10] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path7, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path10, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path7) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path10) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -1792,12 +1792,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path7) {
+function findMiddleware(middleware, path10) {
   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(path10)) {
       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, path10, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -1826,18 +1826,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path7 === "/*") {
-      path7 = "*";
+    if (path10 === "/*") {
+      path10 = "*";
     }
-    const paramCount = (path7.match(/\/:/g) || []).length;
-    if (/\*$/.test(path7)) {
-      const re = buildWildcardRegExp(path7);
+    const paramCount = (path10.match(/\/:/g) || []).length;
+    if (/\*$/.test(path10)) {
+      const re = buildWildcardRegExp(path10);
       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][path10] ||= findMiddleware(middleware[m], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
         });
       } else {
-        middleware[method][path7] ||= findMiddleware(middleware[method], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
+        middleware[method][path10] ||= findMiddleware(middleware[method], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
       }
       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(path10) || [path10];
     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((path10) => [path10, r[method][path10]]) : [];
       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((path10) => [path10, r[METHOD_NAME_ALL][path10]])
         );
       }
     });
@@ -1908,13 +1908,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path7, handler) {
+  add(method, path10, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path7, handler]);
+    this.#routes.push([method, path10, handler]);
   }
-  match(method, path7) {
+  match(method, path10) {
     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, path10);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -1973,10 +1973,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path7, handler) {
+  insert(method, path10, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path7);
+    const parts = splitRoutingPath(path10);
     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, path10) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path7);
+    const parts = splitPath(path10);
     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, path10, handler) {
+    const results = checkOptionalParameter(path10);
     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, path10, handler);
   }
-  match(method, path7) {
-    return this.#node.search(method, path7);
+  match(method, path10) {
+    return this.#node.search(method, path10);
   }
 };
 
@@ -2155,9 +2155,17 @@ 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";
+import * as path8 from "path";
+import {
+  createHandlerAdapter,
+  setRouteConfig,
+  NotFoundError,
+  RedirectError,
+  resolveErrorBoundary,
+  resolveNotFoundBoundary,
+  resolveLoadingBoundary
+} from "@cloudwerk/core";
+import { render, renderStream } from "@cloudwerk/ui";
 
 // src/server/loadHandler.ts
 import * as fs from "fs";
@@ -2558,6 +2566,300 @@ 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/loadLoading.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import { builtinModules as builtinModules7 } from "module";
+import { build as build7 } from "esbuild";
+import { pathToFileURL as pathToFileURL7 } from "url";
+var loadingModuleCache = /* @__PURE__ */ new Map();
+async function loadLoadingModule(absolutePath, verbose = false) {
+  try {
+    const stat = fs7.statSync(absolutePath);
+    const mtime = stat.mtimeMs;
+    const cached = loadingModuleCache.get(absolutePath);
+    if (cached && cached.mtime === mtime) {
+      return cached.module;
+    }
+    const nodeVersion = process.versions.node.split(".")[0];
+    const target = `node${nodeVersion}`;
+    const result = await build7({
+      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
+        ...builtinModules7,
+        ...builtinModules7.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 = findSafeTempDir7(absolutePath);
+    const tempFile = path7.join(tempDir, `.cloudwerk-loading-${cacheKey}.mjs`);
+    fs7.writeFileSync(tempFile, code);
+    try {
+      const rawModule = await import(pathToFileURL7(tempFile).href);
+      if (!rawModule.default) {
+        throw new Error("Loading boundary must have a default export");
+      }
+      if (typeof rawModule.default !== "function") {
+        throw new Error(
+          `Loading boundary default export must be a function (component), got ${typeof rawModule.default}`
+        );
+      }
+      let validatedConfig = void 0;
+      if ("config" in rawModule && rawModule.config !== void 0) {
+        if (typeof rawModule.config !== "object" || rawModule.config === null) {
+          throw new Error(
+            `Loading boundary config export must be an object, got ${typeof rawModule.config}`
+          );
+        }
+        validatedConfig = rawModule.config;
+      }
+      const module = {
+        default: rawModule.default,
+        config: validatedConfig
+      };
+      loadingModuleCache.set(absolutePath, { module, mtime });
+      return module;
+    } finally {
+      try {
+        fs7.unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile loading boundary at ${absolutePath}: ${message}`);
+  }
+}
+function findSafeTempDir7(filePath) {
+  let dir = path7.dirname(filePath);
+  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path7.basename(p));
+  while (hasSpecialChars(dir)) {
+    const parent = path7.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return dir;
+}
+
 // src/server/parseSearchParams.ts
 function parseSearchParams(c) {
   const result = {};
@@ -2597,9 +2899,6 @@ 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) };
     }
@@ -2614,16 +2913,13 @@ async function executeAction(action, args, c) {
     }
     return { data: result ?? {} };
   } 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) {
+async function registerRoutes(app, manifest, scanResult, logger, verbose = false) {
   const registeredRoutes = [];
   for (const route of manifest.routes) {
     if (route.fileType === "page") {
@@ -2635,13 +2931,26 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
           route.layouts.map((layoutPath) => loadLayoutModule(layoutPath, verbose))
         );
         const layouts = layoutModules.map((m) => m.default);
+        const loadingPath = resolveLoadingBoundary(route.filePath, scanResult.loading);
+        let loadingModule = null;
+        if (loadingPath) {
+          try {
+            loadingModule = await loadLoadingModule(loadingPath, verbose);
+            if (verbose) {
+              logger.info(`Loaded loading boundary: ${loadingPath} -> ${route.urlPattern}`);
+            }
+          } catch (loadingError) {
+            const loadingMessage = loadingError instanceof Error ? loadingError.message : String(loadingError);
+            logger.error(`Failed to load loading boundary: ${loadingMessage}`);
+          }
+        }
         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}`
+                `Applied middleware: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`
               );
             }
           }
@@ -2653,12 +2962,70 @@ 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 pathname = new URL(request.url).pathname;
+          const layoutLoaderData = [];
+          const streamingDisabled = pageModule.config?.streaming === false;
+          const useStreaming = loadingModule && !streamingDisabled;
+          if (useStreaming) {
+            try {
+              const LoadingComponent = loadingModule.default;
+              const loadingProps = { params, searchParams, pathname };
+              let loadingElement = await Promise.resolve(LoadingComponent(loadingProps));
+              for (let i = layouts.length - 1; i >= 0; i--) {
+                const Layout = layouts[i];
+                const layoutProps = {
+                  children: loadingElement,
+                  params
+                  // Pass empty objects for layout loader data since loaders haven't run
+                };
+                loadingElement = await Promise.resolve(Layout(layoutProps));
+              }
+              const contentPromise = (async () => {
+                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) {
+                      throw new Error("Redirect during streaming not supported");
+                    }
+                    layoutLoaderData[index] = result.data;
+                  } else {
+                    layoutLoaderData[index] = {};
+                  }
+                }
+                let pageLoaderData = {};
+                if (pageModule.loader) {
+                  const result = await executeLoader(pageModule.loader, loaderArgs, c);
+                  if (result.response) {
+                    throw new Error("Redirect during streaming not supported");
+                  }
+                  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 element;
+              })();
+              return renderStream(loadingElement, contentPromise);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              logger.error(`Streaming error in ${route.filePath}: ${message}`);
+            }
+          }
           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) {
@@ -2692,6 +3059,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(
@@ -2712,17 +3140,17 @@ async function registerRoutes(app, manifest, logger, verbose = false) {
           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 params = c.req.param();
-                const searchParams = parseSearchParams(c);
-                const request = c.req.raw;
                 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 };
-                const layoutLoaderData = [];
                 for (let index = 0; index < layoutModules.length; index++) {
                   const layoutModule = layoutModules[index];
                   if (layoutModule.loader) {
@@ -2761,6 +3189,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} 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(
@@ -2793,7 +3282,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: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`);
           }
         }
       }
@@ -2861,7 +3350,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);
@@ -2892,7 +3381,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(
       {
@@ -2929,8 +3418,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 ? path9.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs8.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -2943,7 +3432,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 (!fs8.existsSync(routesDir)) {
       throw new CliError(
         `Routes directory does not exist: ${routesDir}`,
         "ENOENT",
@@ -2978,7 +3467,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.2.0",
+  "version": "0.3.0",
   "description": "Dev server, build, deploy commands for Cloudwerk",
   "repository": {
     "type": "git",
@@ -25,8 +25,8 @@
     "commander": "^12.1.0",
     "esbuild": "^0.25.0",
     "picocolors": "^1.1.0",
-    "@cloudwerk/core": "^0.2.0",
-    "@cloudwerk/ui": "^0.1.1"
+    "@cloudwerk/core": "^0.3.0",
+    "@cloudwerk/ui": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",