@cloudwerk/cli 0.2.1 → 0.3.0

package/dist/index.js

@@ -4,8 +4,8 @@
 import { program } from "commander";
 
 // src/commands/dev.ts
-import * as path8 from "path";
-import * as fs7 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, path9, 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("]") + " " + path9 + " " + 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 = (path9) => {
-  const paths = path9.split("/");
+var splitPath = (path10) => {
+  const paths = path10.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path9 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path9);
+  const { groups, path: path10 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path10);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path9) => {
+var extractGroupsFromPath = (path10) => {
   const groups = [];
-  path9 = path9.replace(/\{[^}]+\}/g, (match2, index) => {
+  path10 = path10.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path9 };
+  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 path9 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
+      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 = (path9) => {
-  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) {
+var checkOptionalParameter = (path10) => {
+  if (path10.charCodeAt(path10.length - 1) !== 63 || !path10.includes(":")) {
     return null;
   }
-  const segments = path9.split("/");
+  const segments = path10.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -474,9 +474,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path9 = "/", matchResult = [[]]) {
+  constructor(request, path10 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path9;
+    this.path = path10;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1212,8 +1212,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path9, ...handlers) => {
-      for (const p of [path9].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(path9, app) {
-    const subApp = this.basePath(path9);
+  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(path9) {
+  basePath(path10) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path9);
+    subApp._basePath = mergePath(this._basePath, path10);
     return subApp;
   }
   /**
@@ -1373,7 +1373,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path9, 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, path9);
+      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(path9, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path10, "*"), handler);
     return this;
   }
-  #addRoute(method, path9, handler) {
+  #addRoute(method, path10, handler) {
     method = method.toUpperCase();
-    path9 = mergePath(this._basePath, path9);
-    const r = { basePath: this._basePath, path: path9, method, handler };
-    this.router.add(method, path9, [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 path9 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path9);
+    const path10 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path10);
     const c = new Context(request, {
-      path: path9,
+      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, path9) {
+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, path9) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path9);
+  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(path9, index, pathErrorCheckOnly) {
+  insert(path10, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path9 = path9.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 = path9.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(path9) {
-  return wildcardRegExpCache[path9] ??= new RegExp(
-    path9 === "*" ? "" : `^${path9.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, path9, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path10, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path9] = [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(path9, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path10, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : 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, path9) {
+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(path9)) {
+    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, path9, handler) {
+  add(method, path10, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -1826,18 +1826,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path9 === "/*") {
-      path9 = "*";
+    if (path10 === "/*") {
+      path10 = "*";
     }
-    const paramCount = (path9.match(/\/:/g) || []).length;
-    if (/\*$/.test(path9)) {
-      const re = buildWildcardRegExp(path9);
+    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][path9] ||= findMiddleware(middleware[m], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
+          middleware[m][path10] ||= findMiddleware(middleware[m], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
         });
       } else {
-        middleware[method][path9] ||= findMiddleware(middleware[method], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
+        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(path9) || [path9];
+    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((path9) => [path9, r[method][path9]]) : [];
+      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((path9) => [path9, r[METHOD_NAME_ALL][path9]])
+          ...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, path9, handler) {
+  add(method, path10, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path9, handler]);
+    this.#routes.push([method, path10, handler]);
   }
-  match(method, path9) {
+  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, path9);
+        res = router.match(method, path10);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -1973,10 +1973,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path9, handler) {
+  insert(method, path10, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path9);
+    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, path9) {
+  search(method, path10) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path9);
+    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, path9, handler) {
-    const results = checkOptionalParameter(path9);
+  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, path9, handler);
+    this.#node.insert(method, path10, handler);
   }
-  match(method, path9) {
-    return this.#node.search(method, path9);
+  match(method, path10) {
+    return this.#node.search(method, path10);
   }
 };
 
@@ -2155,16 +2155,17 @@ import { contextMiddleware } from "@cloudwerk/core";
 import { setActiveRenderer, getAvailableRenderers } from "@cloudwerk/ui";
 
 // src/server/registerRoutes.ts
-import * as path7 from "path";
+import * as path8 from "path";
 import {
   createHandlerAdapter,
   setRouteConfig,
   NotFoundError,
   RedirectError,
   resolveErrorBoundary,
-  resolveNotFoundBoundary
+  resolveNotFoundBoundary,
+  resolveLoadingBoundary
 } from "@cloudwerk/core";
-import { render } from "@cloudwerk/ui";
+import { render, renderStream } from "@cloudwerk/ui";
 
 // src/server/loadHandler.ts
 import * as fs from "fs";
@@ -2761,6 +2762,104 @@ function findSafeTempDir6(filePath) {
   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 = {};
@@ -2832,13 +2931,26 @@ async function registerRoutes(app, manifest, scanResult, 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: ${path7.basename(middlewarePath)} -> ${route.urlPattern}`
+                `Applied middleware: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`
               );
             }
           }
@@ -2853,7 +2965,65 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
           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 loaderArgs = { params, request, context: c };
             for (let index = 0; index < layoutModules.length; index++) {
@@ -3112,7 +3282,7 @@ async function registerRoutes(app, manifest, scanResult, logger, verbose = false
         if (middlewareHandler) {
           app.use(route.urlPattern, middlewareHandler);
           if (verbose) {
-            logger.info(`Applied middleware: ${path7.basename(middlewarePath)} -> ${route.urlPattern}`);
+            logger.info(`Applied middleware: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`);
           }
         }
       }
@@ -3248,8 +3418,8 @@ async function dev(pathArg, options) {
   const verbose = options.verbose ?? false;
   const logger = createLogger(verbose);
   try {
-    const cwd = pathArg ? path8.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs7.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",
@@ -3262,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 (!fs7.existsSync(routesDir)) {
+    if (!fs8.existsSync(routesDir)) {
       throw new CliError(
         `Routes directory does not exist: ${routesDir}`,
         "ENOENT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/cli",
-  "version": "0.2.1",
+  "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.1",
-    "@cloudwerk/ui": "^0.1.1"
+    "@cloudwerk/core": "^0.3.0",
+    "@cloudwerk/ui": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",