npm - @cloudwerk/cli - Versions diffs - 0.6.0 → 0.7.0 - Mend

@cloudwerk/cli 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +306 -3999
package/package.json +7 -3

package/dist/index.js CHANGED Viewed

@@ -4,21 +4,12 @@
 import { program } from "commander";
 // src/commands/dev.ts
-import * as path10 from "path";
-import * as fs10 from "fs";
+import * as path from "path";
+import * as fs from "fs";
 import * as os from "os";
-import { serve } from "@hono/node-server";
-import {
-  loadConfig,
-  scanRoutes,
-  buildRouteManifest,
-  resolveLayouts,
-  resolveMiddleware,
-  resolveRoutesDir as resolveRoutesDir2,
-  hasErrors,
-  formatErrors,
-  formatWarnings
-} from "@cloudwerk/core";
+import { createServer } from "vite";
+import devServer from "@hono/vite-dev-server";
+import cloudwerk from "@cloudwerk/vite-plugin";
 // src/types.ts
 var CliError = class extends Error {
@@ -73,3655 +64,56 @@ function printStartupBanner(version, localUrl, networkUrl, routes, startupTime)
       const methodColor = getMethodColor(route.method);
       console.log(
         pc.dim("    ") + methodColor(route.method.padEnd(6)) + " " + route.pattern
-      );
-    }
-    if (remainingCount > 0) {
-      console.log(pc.dim(`    ... and ${remainingCount} more routes`));
-    }
-    console.log();
-  }
-  console.log(pc.dim(`  Ready in ${startupTime}ms`));
-  console.log();
-}
-function getMethodColor(method) {
-  switch (method.toUpperCase()) {
-    case "GET":
-      return pc.green;
-    case "POST":
-      return pc.blue;
-    case "PUT":
-      return pc.yellow;
-    case "PATCH":
-      return pc.magenta;
-    case "DELETE":
-      return pc.red;
-    case "OPTIONS":
-      return pc.cyan;
-    case "HEAD":
-      return pc.gray;
-    default:
-      return pc.white;
-  }
-}
-function printError(message, suggestion) {
-  console.log();
-  console.log(pc.red("Error: ") + message);
-  if (suggestion) {
-    console.log();
-    console.log(pc.dim("  " + suggestion));
-  }
-  console.log();
-}
-function logRequest(method, path16, status, duration) {
-  const methodColor = getMethodColor(method);
-  const statusColor = status >= 400 ? pc.red : status >= 300 ? pc.yellow : pc.green;
-  console.log(
-    pc.dim("[") + methodColor(method.padEnd(6)) + pc.dim("]") + " " + path16 + " " + statusColor(String(status)) + " " + pc.dim(`${duration}ms`)
-  );
-}
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/compose.js
-var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
-    let index = -1;
-    return dispatch(0);
-    async function dispatch(i) {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      let res;
-      let isError = false;
-      let handler;
-      if (middleware[i]) {
-        handler = middleware[i][0][0];
-        context.req.routeIndex = i;
-      } else {
-        handler = i === middleware.length && next || void 0;
-      }
-      if (handler) {
-        try {
-          res = await handler(context, () => dispatch(i + 1));
-        } catch (err) {
-          if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
-            isError = true;
-          } else {
-            throw err;
-          }
-        }
-      } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
-        }
-      }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
-      }
-      return context;
-    }
-  };
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/request/constants.js
-var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/utils/body.js
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-  const contentType = headers.get("Content-Type");
-  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
-    return parseFormData(request, { all, dot });
-  }
-  return {};
-};
-async function parseFormData(request, options) {
-  const formData = await request.formData();
-  if (formData) {
-    return convertFormDataToBodyData(formData, options);
-  }
-  return {};
-}
-function convertFormDataToBodyData(formData, options) {
-  const form = /* @__PURE__ */ Object.create(null);
-  formData.forEach((value, key) => {
-    const shouldParseAllValues = options.all || key.endsWith("[]");
-    if (!shouldParseAllValues) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-  if (options.dot) {
-    Object.entries(form).forEach(([key, value]) => {
-      const shouldParseDotValues = key.includes(".");
-      if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
-        delete form[key];
-      }
-    });
-  }
-  return form;
-}
-var handleParsingAllValues = (form, key, value) => {
-  if (form[key] !== void 0) {
-    if (Array.isArray(form[key])) {
-      ;
-      form[key].push(value);
-    } else {
-      form[key] = [form[key], value];
-    }
-  } else {
-    if (!key.endsWith("[]")) {
-      form[key] = value;
-    } else {
-      form[key] = [value];
-    }
-  }
-};
-var handleParsingNestedValues = (form, key, value) => {
-  let nestedForm = form;
-  const keys = key.split(".");
-  keys.forEach((key2, index) => {
-    if (index === keys.length - 1) {
-      nestedForm[key2] = value;
-    } else {
-      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
-        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-      }
-      nestedForm = nestedForm[key2];
-    }
-  });
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/utils/url.js
-var splitPath = (path16) => {
-  const paths = path16.split("/");
-  if (paths[0] === "") {
-    paths.shift();
-  }
-  return paths;
-};
-var splitRoutingPath = (routePath) => {
-  const { groups, path: path16 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path16);
-  return replaceGroupMarks(paths, groups);
-};
-var extractGroupsFromPath = (path16) => {
-  const groups = [];
-  path16 = path16.replace(/\{[^}]+\}/g, (match2, index) => {
-    const mark = `@${index}`;
-    groups.push([mark, match2]);
-    return mark;
-  });
-  return { groups, path: path16 };
-};
-var replaceGroupMarks = (paths, groups) => {
-  for (let i = groups.length - 1; i >= 0; i--) {
-    const [mark] = groups[i];
-    for (let j = paths.length - 1; j >= 0; j--) {
-      if (paths[j].includes(mark)) {
-        paths[j] = paths[j].replace(mark, groups[i][1]);
-        break;
-      }
-    }
-  }
-  return paths;
-};
-var patternCache = {};
-var getPattern = (label, next) => {
-  if (label === "*") {
-    return "*";
-  }
-  const match2 = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match2) {
-    const cacheKey = `${label}#${next}`;
-    if (!patternCache[cacheKey]) {
-      if (match2[2]) {
-        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match2[1], new RegExp(`^${match2[2]}(?=/${next})`)] : [label, match2[1], new RegExp(`^${match2[2]}$`)];
-      } else {
-        patternCache[cacheKey] = [label, match2[1], true];
-      }
-    }
-    return patternCache[cacheKey];
-  }
-  return null;
-};
-var tryDecode = (str, decoder) => {
-  try {
-    return decoder(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
-      try {
-        return decoder(match2);
-      } catch {
-        return match2;
-      }
-    });
-  }
-};
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
-  const url = request.url;
-  const start = url.indexOf("/", url.indexOf(":") + 4);
-  let i = start;
-  for (; i < url.length; i++) {
-    const charCode = url.charCodeAt(i);
-    if (charCode === 37) {
-      const queryIndex = url.indexOf("?", i);
-      const path16 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path16.includes("%25") ? path16.replace(/%25/g, "%2525") : path16);
-    } else if (charCode === 63) {
-      break;
-    }
-  }
-  return url.slice(start, i);
-};
-var getPathNoStrict = (request) => {
-  const result = getPath(request);
-  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
-};
-var mergePath = (base, sub, ...rest) => {
-  if (rest.length) {
-    sub = mergePath(sub, ...rest);
-  }
-  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
-};
-var checkOptionalParameter = (path16) => {
-  if (path16.charCodeAt(path16.length - 1) !== 63 || !path16.includes(":")) {
-    return null;
-  }
-  const segments = path16.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
-        } else {
-          results.push(basePath);
-        }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
-      } else {
-        basePath += "/" + segment;
-      }
-    }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
-  if (value.indexOf("+") !== -1) {
-    value = value.replace(/\+/g, " ");
-  }
-  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
-};
-var _getQueryParam = (url, key, multiple) => {
-  let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url.indexOf("?", 8);
-    if (keyIndex2 === -1) {
-      return void 0;
-    }
-    if (!url.startsWith(key, keyIndex2 + 1)) {
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    while (keyIndex2 !== -1) {
-      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-      if (trailingKeyCode === 61) {
-        const valueIndex = keyIndex2 + key.length + 2;
-        const endIndex = url.indexOf("&", valueIndex);
-        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
-      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
-        return "";
-      }
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    encoded = /[%+]/.test(url);
-    if (!encoded) {
-      return void 0;
-    }
-  }
-  const results = {};
-  encoded ??= /[%+]/.test(url);
-  let keyIndex = url.indexOf("?", 8);
-  while (keyIndex !== -1) {
-    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-    let valueIndex = url.indexOf("=", keyIndex);
-    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
-      valueIndex = -1;
-    }
-    let name = url.slice(
-      keyIndex + 1,
-      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
-    );
-    if (encoded) {
-      name = _decodeURI(name);
-    }
-    keyIndex = nextKeyIndex;
-    if (name === "") {
-      continue;
-    }
-    let value;
-    if (valueIndex === -1) {
-      value = "";
-    } else {
-      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
-      if (encoded) {
-        value = _decodeURI(value);
-      }
-    }
-    if (multiple) {
-      if (!(results[name] && Array.isArray(results[name]))) {
-        results[name] = [];
-      }
-      ;
-      results[name].push(value);
-    } else {
-      results[name] ??= value;
-    }
-  }
-  return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key) => {
-  return _getQueryParam(url, key, true);
-};
-var decodeURIComponent_ = decodeURIComponent;
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-var HonoRequest = class {
-  /**
-   * `.raw` can get the raw Request object.
-   *
-   * @see {@link https://hono.dev/docs/api/request#raw}
-   *
-   * @example
-   * ```ts
-   * // For Cloudflare Workers
-   * app.post('/', async (c) => {
-   *   const metadata = c.req.raw.cf?.hostMetadata?
-   *   ...
-   * })
-   * ```
-   */
-  raw;
-  #validatedData;
-  // Short name of validatedData
-  #matchResult;
-  routeIndex = 0;
-  /**
-   * `.path` can get the pathname of the request.
-   *
-   * @see {@link https://hono.dev/docs/api/request#path}
-   *
-   * @example
-   * ```ts
-   * app.get('/about/me', (c) => {
-   *   const pathname = c.req.path // `/about/me`
-   * })
-   * ```
-   */
-  path;
-  bodyCache = {};
-  constructor(request, path16 = "/", matchResult = [[]]) {
-    this.raw = request;
-    this.path = path16;
-    this.#matchResult = matchResult;
-    this.#validatedData = {};
-  }
-  param(key) {
-    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
-  }
-  #getDecodedParam(key) {
-    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-    const param = this.#getParamValue(paramKey);
-    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
-  }
-  #getAllDecodedParams() {
-    const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-    for (const key of keys) {
-      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value !== void 0) {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
-      }
-    }
-    return decoded;
-  }
-  #getParamValue(paramKey) {
-    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-  }
-  query(key) {
-    return getQueryParam(this.url, key);
-  }
-  queries(key) {
-    return getQueryParams(this.url, key);
-  }
-  header(name) {
-    if (name) {
-      return this.raw.headers.get(name) ?? void 0;
-    }
-    const headerData = {};
-    this.raw.headers.forEach((value, key) => {
-      headerData[key] = value;
-    });
-    return headerData;
-  }
-  async parseBody(options) {
-    return this.bodyCache.parsedBody ??= await parseBody(this, options);
-  }
-  #cachedBody = (key) => {
-    const { bodyCache, raw: raw2 } = this;
-    const cachedBody = bodyCache[key];
-    if (cachedBody) {
-      return cachedBody;
-    }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
-      return bodyCache[anyCachedKey].then((body) => {
-        if (anyCachedKey === "json") {
-          body = JSON.stringify(body);
-        }
-        return new Response(body)[key]();
-      });
-    }
-    return bodyCache[key] = raw2[key]();
-  };
-  /**
-   * `.json()` can parse Request body of type `application/json`
-   *
-   * @see {@link https://hono.dev/docs/api/request#json}
-   *
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.json()
-   * })
-   * ```
-   */
-  json() {
-    return this.#cachedBody("text").then((text) => JSON.parse(text));
-  }
-  /**
-   * `.text()` can parse Request body of type `text/plain`
-   *
-   * @see {@link https://hono.dev/docs/api/request#text}
-   *
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.text()
-   * })
-   * ```
-   */
-  text() {
-    return this.#cachedBody("text");
-  }
-  /**
-   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
-   *
-   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
-   *
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.arrayBuffer()
-   * })
-   * ```
-   */
-  arrayBuffer() {
-    return this.#cachedBody("arrayBuffer");
-  }
-  /**
-   * Parses the request body as a `Blob`.
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.blob();
-   * });
-   * ```
-   * @see https://hono.dev/docs/api/request#blob
-   */
-  blob() {
-    return this.#cachedBody("blob");
-  }
-  /**
-   * Parses the request body as `FormData`.
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.formData();
-   * });
-   * ```
-   * @see https://hono.dev/docs/api/request#formdata
-   */
-  formData() {
-    return this.#cachedBody("formData");
-  }
-  /**
-   * Adds validated data to the request.
-   *
-   * @param target - The target of the validation.
-   * @param data - The validated data to add.
-   */
-  addValidatedData(target, data) {
-    this.#validatedData[target] = data;
-  }
-  valid(target) {
-    return this.#validatedData[target];
-  }
-  /**
-   * `.url()` can get the request url strings.
-   *
-   * @see {@link https://hono.dev/docs/api/request#url}
-   *
-   * @example
-   * ```ts
-   * app.get('/about/me', (c) => {
-   *   const url = c.req.url // `http://localhost:8787/about/me`
-   *   ...
-   * })
-   * ```
-   */
-  get url() {
-    return this.raw.url;
-  }
-  /**
-   * `.method()` can get the method name of the request.
-   *
-   * @see {@link https://hono.dev/docs/api/request#method}
-   *
-   * @example
-   * ```ts
-   * app.get('/about/me', (c) => {
-   *   const method = c.req.method // `GET`
-   * })
-   * ```
-   */
-  get method() {
-    return this.raw.method;
-  }
-  get [GET_MATCH_RESULT]() {
-    return this.#matchResult;
-  }
-  /**
-   * `.matchedRoutes()` can return a matched route in the handler
-   *
-   * @deprecated
-   *
-   * Use matchedRoutes helper defined in "hono/route" instead.
-   *
-   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
-   *
-   * @example
-   * ```ts
-   * app.use('*', async function logger(c, next) {
-   *   await next()
-   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
-   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
-   *     console.log(
-   *       method,
-   *       ' ',
-   *       path,
-   *       ' '.repeat(Math.max(10 - path.length, 0)),
-   *       name,
-   *       i === c.req.routeIndex ? '<- respond from here' : ''
-   *     )
-   *   })
-   * })
-   * ```
-   */
-  get matchedRoutes() {
-    return this.#matchResult[0].map(([[, route]]) => route);
-  }
-  /**
-   * `routePath()` can retrieve the path registered within the handler
-   *
-   * @deprecated
-   *
-   * Use routePath helper defined in "hono/route" instead.
-   *
-   * @see {@link https://hono.dev/docs/api/request#routepath}
-   *
-   * @example
-   * ```ts
-   * app.get('/posts/:id', (c) => {
-   *   return c.json({ path: c.req.routePath })
-   * })
-   * ```
-   */
-  get routePath() {
-    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/utils/html.js
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
-};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
-    (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
-    ).then(() => buffer[0])
-  );
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
-    return resStr;
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/context.js
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setDefaultContentType = (contentType, headers) => {
-  return {
-    "Content-Type": contentType,
-    ...headers
-  };
-};
-var Context = class {
-  #rawRequest;
-  #req;
-  /**
-   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
-   *
-   * @see {@link https://hono.dev/docs/api/context#env}
-   *
-   * @example
-   * ```ts
-   * // Environment object for Cloudflare Workers
-   * app.get('*', async c => {
-   *   const counter = c.env.COUNTER
-   * })
-   * ```
-   */
-  env = {};
-  #var;
-  finalized = false;
-  /**
-   * `.error` can get the error object from the middleware if the Handler throws an error.
-   *
-   * @see {@link https://hono.dev/docs/api/context#error}
-   *
-   * @example
-   * ```ts
-   * app.use('*', async (c, next) => {
-   *   await next()
-   *   if (c.error) {
-   *     // do something...
-   *   }
-   * })
-   * ```
-   */
-  error;
-  #status;
-  #executionCtx;
-  #res;
-  #layout;
-  #renderer;
-  #notFoundHandler;
-  #preparedHeaders;
-  #matchResult;
-  #path;
-  /**
-   * Creates an instance of the Context class.
-   *
-   * @param req - The Request object.
-   * @param options - Optional configuration options for the context.
-   */
-  constructor(req, options) {
-    this.#rawRequest = req;
-    if (options) {
-      this.#executionCtx = options.executionCtx;
-      this.env = options.env;
-      this.#notFoundHandler = options.notFoundHandler;
-      this.#path = options.path;
-      this.#matchResult = options.matchResult;
-    }
-  }
-  /**
-   * `.req` is the instance of {@link HonoRequest}.
-   */
-  get req() {
-    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-    return this.#req;
-  }
-  /**
-   * @see {@link https://hono.dev/docs/api/context#event}
-   * The FetchEvent associated with the current request.
-   *
-   * @throws Will throw an error if the context does not have a FetchEvent.
-   */
-  get event() {
-    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no FetchEvent");
-    }
-  }
-  /**
-   * @see {@link https://hono.dev/docs/api/context#executionctx}
-   * The ExecutionContext associated with the current request.
-   *
-   * @throws Will throw an error if the context does not have an ExecutionContext.
-   */
-  get executionCtx() {
-    if (this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no ExecutionContext");
-    }
-  }
-  /**
-   * @see {@link https://hono.dev/docs/api/context#res}
-   * The Response object for the current request.
-   */
-  get res() {
-    return this.#res ||= new Response(null, {
-      headers: this.#preparedHeaders ??= new Headers()
-    });
-  }
-  /**
-   * Sets the Response object for the current request.
-   *
-   * @param _res - The Response object to set.
-   */
-  set res(_res) {
-    if (this.#res && _res) {
-      _res = new Response(_res.body, _res);
-      for (const [k, v] of this.#res.headers.entries()) {
-        if (k === "content-type") {
-          continue;
-        }
-        if (k === "set-cookie") {
-          const cookies = this.#res.headers.getSetCookie();
-          _res.headers.delete("set-cookie");
-          for (const cookie of cookies) {
-            _res.headers.append("set-cookie", cookie);
-          }
-        } else {
-          _res.headers.set(k, v);
-        }
-      }
-    }
-    this.#res = _res;
-    this.finalized = true;
-  }
-  /**
-   * `.render()` can create a response within a layout.
-   *
-   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-   *
-   * @example
-   * ```ts
-   * app.get('/', (c) => {
-   *   return c.render('Hello!')
-   * })
-   * ```
-   */
-  render = (...args) => {
-    this.#renderer ??= (content) => this.html(content);
-    return this.#renderer(...args);
-  };
-  /**
-   * Sets the layout for the response.
-   *
-   * @param layout - The layout to set.
-   * @returns The layout function.
-   */
-  setLayout = (layout) => this.#layout = layout;
-  /**
-   * Gets the current layout for the response.
-   *
-   * @returns The current layout function.
-   */
-  getLayout = () => this.#layout;
-  /**
-   * `.setRenderer()` can set the layout in the custom middleware.
-   *
-   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-   *
-   * @example
-   * ```tsx
-   * app.use('*', async (c, next) => {
-   *   c.setRenderer((content) => {
-   *     return c.html(
-   *       <html>
-   *         <body>
-   *           <p>{content}</p>
-   *         </body>
-   *       </html>
-   *     )
-   *   })
-   *   await next()
-   * })
-   * ```
-   */
-  setRenderer = (renderer) => {
-    this.#renderer = renderer;
-  };
-  /**
-   * `.header()` can set headers.
-   *
-   * @see {@link https://hono.dev/docs/api/context#header}
-   *
-   * @example
-   * ```ts
-   * app.get('/welcome', (c) => {
-   *   // Set headers
-   *   c.header('X-Message', 'Hello!')
-   *   c.header('Content-Type', 'text/plain')
-   *
-   *   return c.body('Thank you for coming')
-   * })
-   * ```
-   */
-  header = (name, value, options) => {
-    if (this.finalized) {
-      this.#res = new Response(this.#res.body, this.#res);
-    }
-    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
-    if (value === void 0) {
-      headers.delete(name);
-    } else if (options?.append) {
-      headers.append(name, value);
-    } else {
-      headers.set(name, value);
-    }
-  };
-  status = (status) => {
-    this.#status = status;
-  };
-  /**
-   * `.set()` can set the value specified by the key.
-   *
-   * @see {@link https://hono.dev/docs/api/context#set-get}
-   *
-   * @example
-   * ```ts
-   * app.use('*', async (c, next) => {
-   *   c.set('message', 'Hono is hot!!')
-   *   await next()
-   * })
-   * ```
-   */
-  set = (key, value) => {
-    this.#var ??= /* @__PURE__ */ new Map();
-    this.#var.set(key, value);
-  };
-  /**
-   * `.get()` can use the value specified by the key.
-   *
-   * @see {@link https://hono.dev/docs/api/context#set-get}
-   *
-   * @example
-   * ```ts
-   * app.get('/', (c) => {
-   *   const message = c.get('message')
-   *   return c.text(`The message is "${message}"`)
-   * })
-   * ```
-   */
-  get = (key) => {
-    return this.#var ? this.#var.get(key) : void 0;
-  };
-  /**
-   * `.var` can access the value of a variable.
-   *
-   * @see {@link https://hono.dev/docs/api/context#var}
-   *
-   * @example
-   * ```ts
-   * const result = c.var.client.oneMethod()
-   * ```
-   */
-  // c.var.propName is a read-only
-  get var() {
-    if (!this.#var) {
-      return {};
-    }
-    return Object.fromEntries(this.#var);
-  }
-  #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
-          responseHeaders.append(key, value);
-        } else {
-          responseHeaders.set(key, value);
-        }
-      }
-    }
-    if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          responseHeaders.set(k, v);
-        } else {
-          responseHeaders.delete(k);
-          for (const v2 of v) {
-            responseHeaders.append(k, v2);
-          }
-        }
-      }
-    }
-    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return new Response(data, { status, headers: responseHeaders });
-  }
-  newResponse = (...args) => this.#newResponse(...args);
-  /**
-   * `.body()` can return the HTTP response.
-   * You can set headers with `.header()` and set HTTP status code with `.status`.
-   * This can also be set in `.text()`, `.json()` and so on.
-   *
-   * @see {@link https://hono.dev/docs/api/context#body}
-   *
-   * @example
-   * ```ts
-   * app.get('/welcome', (c) => {
-   *   // Set headers
-   *   c.header('X-Message', 'Hello!')
-   *   c.header('Content-Type', 'text/plain')
-   *   // Set HTTP status code
-   *   c.status(201)
-   *
-   *   // Return the response body
-   *   return c.body('Thank you for coming')
-   * })
-   * ```
-   */
-  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
-  /**
-   * `.text()` can render text as `Content-Type:text/plain`.
-   *
-   * @see {@link https://hono.dev/docs/api/context#text}
-   *
-   * @example
-   * ```ts
-   * app.get('/say', (c) => {
-   *   return c.text('Hello!')
-   * })
-   * ```
-   */
-  text = (text, arg, headers) => {
-    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
-      text,
-      arg,
-      setDefaultContentType(TEXT_PLAIN, headers)
-    );
-  };
-  /**
-   * `.json()` can render JSON as `Content-Type:application/json`.
-   *
-   * @see {@link https://hono.dev/docs/api/context#json}
-   *
-   * @example
-   * ```ts
-   * app.get('/api', (c) => {
-   *   return c.json({ message: 'Hello!' })
-   * })
-   * ```
-   */
-  json = (object, arg, headers) => {
-    return this.#newResponse(
-      JSON.stringify(object),
-      arg,
-      setDefaultContentType("application/json", headers)
-    );
-  };
-  html = (html, arg, headers) => {
-    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
-    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
-  };
-  /**
-   * `.redirect()` can Redirect, default status code is 302.
-   *
-   * @see {@link https://hono.dev/docs/api/context#redirect}
-   *
-   * @example
-   * ```ts
-   * app.get('/redirect', (c) => {
-   *   return c.redirect('/')
-   * })
-   * app.get('/redirect-permanently', (c) => {
-   *   return c.redirect('/', 301)
-   * })
-   * ```
-   */
-  redirect = (location, status) => {
-    const locationString = String(location);
-    this.header(
-      "Location",
-      // Multibyes should be encoded
-      // eslint-disable-next-line no-control-regex
-      !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
-    );
-    return this.newResponse(null, status ?? 302);
-  };
-  /**
-   * `.notFound()` can return the Not Found Response.
-   *
-   * @see {@link https://hono.dev/docs/api/context#notfound}
-   *
-   * @example
-   * ```ts
-   * app.get('/notfound', (c) => {
-   *   return c.notFound()
-   * })
-   * ```
-   */
-  notFound = () => {
-    this.#notFoundHandler ??= () => new Response();
-    return this.#notFoundHandler(this);
-  };
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router.js
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/utils/constants.js
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/hono-base.js
-var notFoundHandler = (c) => {
-  return c.text("404 Not Found", 404);
-};
-var errorHandler = (err, c) => {
-  if ("getResponse" in err) {
-    const res = err.getResponse();
-    return c.newResponse(res.body, res);
-  }
-  console.error(err);
-  return c.text("Internal Server Error", 500);
-};
-var Hono = class _Hono {
-  get;
-  post;
-  put;
-  delete;
-  options;
-  patch;
-  all;
-  on;
-  use;
-  /*
-    This class is like an abstract class and does not have a router.
-    To use it, inherit the class and implement router in the constructor.
-  */
-  router;
-  getPath;
-  // Cannot use `#` because it requires visibility at JavaScript runtime.
-  _basePath = "/";
-  #path = "/";
-  routes = [];
-  constructor(options = {}) {
-    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
-    allMethods.forEach((method) => {
-      this[method] = (args1, ...args) => {
-        if (typeof args1 === "string") {
-          this.#path = args1;
-        } else {
-          this.#addRoute(method, this.#path, args1);
-        }
-        args.forEach((handler) => {
-          this.#addRoute(method, this.#path, handler);
-        });
-        return this;
-      };
-    });
-    this.on = (method, path16, ...handlers) => {
-      for (const p of [path16].flat()) {
-        this.#path = p;
-        for (const m of [method].flat()) {
-          handlers.map((handler) => {
-            this.#addRoute(m.toUpperCase(), this.#path, handler);
-          });
-        }
-      }
-      return this;
-    };
-    this.use = (arg1, ...handlers) => {
-      if (typeof arg1 === "string") {
-        this.#path = arg1;
-      } else {
-        this.#path = "*";
-        handlers.unshift(arg1);
-      }
-      handlers.forEach((handler) => {
-        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
-      });
-      return this;
-    };
-    const { strict, ...optionsWithoutStrict } = options;
-    Object.assign(this, optionsWithoutStrict);
-    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
-  }
-  #clone() {
-    const clone = new _Hono({
-      router: this.router,
-      getPath: this.getPath
-    });
-    clone.errorHandler = this.errorHandler;
-    clone.#notFoundHandler = this.#notFoundHandler;
-    clone.routes = this.routes;
-    return clone;
-  }
-  #notFoundHandler = notFoundHandler;
-  // Cannot use `#` because it requires visibility at JavaScript runtime.
-  errorHandler = errorHandler;
-  /**
-   * `.route()` allows grouping other Hono instance in routes.
-   *
-   * @see {@link https://hono.dev/docs/api/routing#grouping}
-   *
-   * @param {string} path - base Path
-   * @param {Hono} app - other Hono instance
-   * @returns {Hono} routed Hono instance
-   *
-   * @example
-   * ```ts
-   * const app = new Hono()
-   * const app2 = new Hono()
-   *
-   * app2.get("/user", (c) => c.text("user"))
-   * app.route("/api", app2) // GET /api/user
-   * ```
-   */
-  route(path16, app) {
-    const subApp = this.basePath(path16);
-    app.routes.map((r) => {
-      let handler;
-      if (app.errorHandler === errorHandler) {
-        handler = r.handler;
-      } else {
-        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
-        handler[COMPOSED_HANDLER] = r.handler;
-      }
-      subApp.#addRoute(r.method, r.path, handler);
-    });
-    return this;
-  }
-  /**
-   * `.basePath()` allows base paths to be specified.
-   *
-   * @see {@link https://hono.dev/docs/api/routing#base-path}
-   *
-   * @param {string} path - base Path
-   * @returns {Hono} changed Hono instance
-   *
-   * @example
-   * ```ts
-   * const api = new Hono().basePath('/api')
-   * ```
-   */
-  basePath(path16) {
-    const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path16);
-    return subApp;
-  }
-  /**
-   * `.onError()` handles an error and returns a customized Response.
-   *
-   * @see {@link https://hono.dev/docs/api/hono#error-handling}
-   *
-   * @param {ErrorHandler} handler - request Handler for error
-   * @returns {Hono} changed Hono instance
-   *
-   * @example
-   * ```ts
-   * app.onError((err, c) => {
-   *   console.error(`${err}`)
-   *   return c.text('Custom Error Message', 500)
-   * })
-   * ```
-   */
-  onError = (handler) => {
-    this.errorHandler = handler;
-    return this;
-  };
-  /**
-   * `.notFound()` allows you to customize a Not Found Response.
-   *
-   * @see {@link https://hono.dev/docs/api/hono#not-found}
-   *
-   * @param {NotFoundHandler} handler - request handler for not-found
-   * @returns {Hono} changed Hono instance
-   *
-   * @example
-   * ```ts
-   * app.notFound((c) => {
-   *   return c.text('Custom 404 Message', 404)
-   * })
-   * ```
-   */
-  notFound = (handler) => {
-    this.#notFoundHandler = handler;
-    return this;
-  };
-  /**
-   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-   *
-   * @see {@link https://hono.dev/docs/api/hono#mount}
-   *
-   * @param {string} path - base Path
-   * @param {Function} applicationHandler - other Request Handler
-   * @param {MountOptions} [options] - options of `.mount()`
-   * @returns {Hono} mounted Hono instance
-   *
-   * @example
-   * ```ts
-   * import { Router as IttyRouter } from 'itty-router'
-   * import { Hono } from 'hono'
-   * // Create itty-router application
-   * const ittyRouter = IttyRouter()
-   * // GET /itty-router/hello
-   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-   *
-   * const app = new Hono()
-   * app.mount('/itty-router', ittyRouter.handle)
-   * ```
-   *
-   * @example
-   * ```ts
-   * const app = new Hono()
-   * // Send the request to another application without modification.
-   * app.mount('/app', anotherApp, {
-   *   replaceRequest: (req) => req,
-   * })
-   * ```
-   */
-  mount(path16, applicationHandler, options) {
-    let replaceRequest;
-    let optionHandler;
-    if (options) {
-      if (typeof options === "function") {
-        optionHandler = options;
-      } else {
-        optionHandler = options.optionHandler;
-        if (options.replaceRequest === false) {
-          replaceRequest = (request) => request;
-        } else {
-          replaceRequest = options.replaceRequest;
-        }
-      }
-    }
-    const getOptions = optionHandler ? (c) => {
-      const options2 = optionHandler(c);
-      return Array.isArray(options2) ? options2 : [options2];
-    } : (c) => {
-      let executionContext = void 0;
-      try {
-        executionContext = c.executionCtx;
-      } catch {
-      }
-      return [c.env, executionContext];
-    };
-    replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path16);
-      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-      return (request) => {
-        const url = new URL(request.url);
-        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
-        return new Request(url, request);
-      };
-    })();
-    const handler = async (c, next) => {
-      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-      if (res) {
-        return res;
-      }
-      await next();
-    };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path16, "*"), handler);
-    return this;
-  }
-  #addRoute(method, path16, handler) {
-    method = method.toUpperCase();
-    path16 = mergePath(this._basePath, path16);
-    const r = { basePath: this._basePath, path: path16, method, handler };
-    this.router.add(method, path16, [handler, r]);
-    this.routes.push(r);
-  }
-  #handleError(err, c) {
-    if (err instanceof Error) {
-      return this.errorHandler(err, c);
-    }
-    throw err;
-  }
-  #dispatch(request, executionCtx, env, method) {
-    if (method === "HEAD") {
-      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-    }
-    const path16 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path16);
-    const c = new Context(request, {
-      path: path16,
-      matchResult,
-      env,
-      executionCtx,
-      notFoundHandler: this.#notFoundHandler
-    });
-    if (matchResult[0].length === 1) {
-      let res;
-      try {
-        res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.#notFoundHandler(c);
-        });
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-      return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
-      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
-    }
-    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
-    return (async () => {
-      try {
-        const context = await composed(c);
-        if (!context.finalized) {
-          throw new Error(
-            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
-          );
-        }
-        return context.res;
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-    })();
-  }
-  /**
-   * `.fetch()` will be entry point of your app.
-   *
-   * @see {@link https://hono.dev/docs/api/hono#fetch}
-   *
-   * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
-   * @returns {Response | Promise<Response>} response of request
-   *
-   */
-  fetch = (request, ...rest) => {
-    return this.#dispatch(request, rest[1], rest[0], request.method);
-  };
-  /**
-   * `.request()` is a useful method for testing.
-   * You can pass a URL or pathname to send a GET request.
-   * app will return a Response object.
-   * ```ts
-   * test('GET /hello is ok', async () => {
-   *   const res = await app.request('/hello')
-   *   expect(res.status).toBe(200)
-   * })
-   * ```
-   * @see https://hono.dev/docs/api/hono#request
-   */
-  request = (input, requestInit, Env, executionCtx) => {
-    if (input instanceof Request) {
-      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
-    }
-    input = input.toString();
-    return this.fetch(
-      new Request(
-        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
-        requestInit
-      ),
-      Env,
-      executionCtx
-    );
-  };
-  /**
-   * `.fire()` automatically adds a global fetch event listener.
-   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-   * @deprecated
-   * Use `fire` from `hono/service-worker` instead.
-   * ```ts
-   * import { Hono } from 'hono'
-   * import { fire } from 'hono/service-worker'
-   *
-   * const app = new Hono()
-   * // ...
-   * fire(app)
-   * ```
-   * @see https://hono.dev/docs/api/hono#fire
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-   */
-  fire = () => {
-    addEventListener("fetch", (event) => {
-      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-    });
-  };
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/matcher.js
-var emptyParam = [];
-function match(method, path16) {
-  const matchers = this.buildAllMatchers();
-  const match2 = ((method2, path22) => {
-    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-    const staticMatch = matcher[2][path22];
-    if (staticMatch) {
-      return staticMatch;
-    }
-    const match3 = path22.match(matcher[0]);
-    if (!match3) {
-      return [[], emptyParam];
-    }
-    const index = match3.indexOf("", 1);
-    return [matcher[1][index], match3];
-  });
-  this.match = match2;
-  return match2(method, path16);
-}
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/node.js
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = /* @__PURE__ */ Symbol();
-var regExpMetaChars = new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-  if (a.length === 1) {
-    return b.length === 1 ? a < b ? -1 : 1 : -1;
-  }
-  if (b.length === 1) {
-    return 1;
-  }
-  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
-  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-    return -1;
-  }
-  if (a === LABEL_REG_EXP_STR) {
-    return 1;
-  } else if (b === LABEL_REG_EXP_STR) {
-    return -1;
-  }
-  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-}
-var Node = class _Node {
-  #index;
-  #varIndex;
-  #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.#index = index;
-      return;
-    }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        if (regexpStr === ".*") {
-          throw PATH_ERROR;
-        }
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[regexpStr] = new _Node();
-        if (name !== "") {
-          node.#varIndex = context.varIndex++;
-        }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
-    } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[token] = new _Node();
-      }
-    }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-  }
-  buildRegExpStr() {
-    const childKeys = Object.keys(this.#children).sort(compareKey);
-    const strList = childKeys.map((k) => {
-      const c = this.#children[k];
-      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-    });
-    if (typeof this.#index === "number") {
-      strList.unshift(`#${this.#index}`);
-    }
-    if (strList.length === 0) {
-      return "";
-    }
-    if (strList.length === 1) {
-      return strList[0];
-    }
-    return "(?:" + strList.join("|") + ")";
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/reg-exp-router/trie.js
-var Trie = class {
-  #context = { varIndex: 0 };
-  #root = new Node();
-  insert(path16, index, pathErrorCheckOnly) {
-    const paramAssoc = [];
-    const groups = [];
-    for (let i = 0; ; ) {
-      let replaced = false;
-      path16 = path16.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
-      }
-    }
-    const tokens = path16.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
-        }
-      }
-    }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
-  }
-  buildRegExp() {
-    let regexp = this.#root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
-    }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (handlerIndex !== void 0) {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
-      }
-      if (paramIndex !== void 0) {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
-      }
-      return "";
-    });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-  }
-};
-// ../../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(path16) {
-  return wildcardRegExpCache[path16] ??= new RegExp(
-    path16 === "*" ? "" : `^${path16.replace(
-      /\/\*$|([.\\+*[^\]$()])/g,
-      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
-    )}$`
-  );
-}
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path16, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path16] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path16, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path16) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
-      }
-      return [h, paramIndexMap];
-    });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-      const map = handlerData[i][j]?.[1];
-      if (!map) {
-        continue;
-      }
-      const keys = Object.keys(map);
-      for (let k = 0, len3 = keys.length; k < len3; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
-}
-function findMiddleware(middleware, path16) {
-  if (!middleware) {
-    return void 0;
-  }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path16)) {
-      return [...middleware[k]];
-    }
-  }
-  return void 0;
-}
-var RegExpRouter = class {
-  name = "RegExpRouter";
-  #middleware;
-  #routes;
-  constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-  }
-  add(method, path16, handler) {
-    const middleware = this.#middleware;
-    const routes = this.#routes;
-    if (!middleware || !routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    if (!middleware[method]) {
-      ;
-      [middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = /* @__PURE__ */ Object.create(null);
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-        });
-      });
-    }
-    if (path16 === "/*") {
-      path16 = "*";
-    }
-    const paramCount = (path16.match(/\/:/g) || []).length;
-    if (/\*$/.test(path16)) {
-      const re = buildWildcardRegExp(path16);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path16] ||= findMiddleware(middleware[m], path16) || findMiddleware(middleware[METHOD_NAME_ALL], path16) || [];
-        });
-      } else {
-        middleware[method][path16] ||= findMiddleware(middleware[method], path16) || findMiddleware(middleware[METHOD_NAME_ALL], path16) || [];
-      }
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
-          });
-        }
-      });
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
-          );
-        }
-      });
-      return;
-    }
-    const paths = checkOptionalParameter(path16) || [path16];
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path22 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path22] ||= [
-            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
-          ];
-          routes[m][path22].push([handler, paramCount - len + i + 1]);
-        }
-      });
-    }
-  }
-  match = match;
-  buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-      matchers[method] ||= this.#buildMatcher(method);
-    });
-    this.#middleware = this.#routes = void 0;
-    clearWildcardRegExpCache();
-    return matchers;
-  }
-  #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path16) => [path16, r[method][path16]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path16) => [path16, r[METHOD_NAME_ALL][path16]])
-        );
-      }
-    });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
-    }
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/smart-router/router.js
-var SmartRouter = class {
-  name = "SmartRouter";
-  #routers = [];
-  #routes = [];
-  constructor(init) {
-    this.#routers = init.routers;
-  }
-  add(method, path16, handler) {
-    if (!this.#routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    this.#routes.push([method, path16, handler]);
-  }
-  match(method, path16) {
-    if (!this.#routes) {
-      throw new Error("Fatal error");
-    }
-    const routers = this.#routers;
-    const routes = this.#routes;
-    const len = routers.length;
-    let i = 0;
-    let res;
-    for (; i < len; i++) {
-      const router = routers[i];
-      try {
-        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
-          router.add(...routes[i2]);
-        }
-        res = router.match(method, path16);
-      } catch (e) {
-        if (e instanceof UnsupportedPathError) {
-          continue;
-        }
-        throw e;
-      }
-      this.match = router.match.bind(router);
-      this.#routers = [router];
-      this.#routes = void 0;
-      break;
-    }
-    if (i === len) {
-      throw new Error("Fatal error");
-    }
-    this.name = `SmartRouter + ${this.activeRouter.name}`;
-    return res;
-  }
-  get activeRouter() {
-    if (this.#routes || this.#routers.length !== 1) {
-      throw new Error("No active router has been determined yet.");
-    }
-    return this.#routers[0];
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/trie-router/node.js
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var Node2 = class _Node2 {
-  #methods;
-  #children;
-  #patterns;
-  #order = 0;
-  #params = emptyParams;
-  constructor(method, handler, children) {
-    this.#children = children || /* @__PURE__ */ Object.create(null);
-    this.#methods = [];
-    if (method && handler) {
-      const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0 };
-      this.#methods = [m];
-    }
-    this.#patterns = [];
-  }
-  insert(method, path16, handler) {
-    this.#order = ++this.#order;
-    let curNode = this;
-    const parts = splitRoutingPath(path16);
-    const possibleKeys = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const p = parts[i];
-      const nextP = parts[i + 1];
-      const pattern = getPattern(p, nextP);
-      const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (key in curNode.#children) {
-        curNode = curNode.#children[key];
-        if (pattern) {
-          possibleKeys.push(pattern[1]);
-        }
-        continue;
-      }
-      curNode.#children[key] = new _Node2();
-      if (pattern) {
-        curNode.#patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
-      }
-      curNode = curNode.#children[key];
-    }
-    curNode.#methods.push({
-      [method]: {
-        handler,
-        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-        score: this.#order
-      }
-    });
-    return curNode;
-  }
-  #getHandlerSets(node, method, nodeParams, params) {
-    const handlerSets = [];
-    for (let i = 0, len = node.#methods.length; i < len; i++) {
-      const m = node.#methods[i];
-      const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = {};
-      if (handlerSet !== void 0) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSets.push(handlerSet);
-        if (nodeParams !== emptyParams || params && params !== emptyParams) {
-          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
-            const key = handlerSet.possibleKeys[i2];
-            const processed = processedSet[handlerSet.score];
-            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-            processedSet[handlerSet.score] = true;
-          }
-        }
-      }
-    }
-    return handlerSets;
-  }
-  search(method, path16) {
-    const handlerSets = [];
-    this.#params = emptyParams;
-    const curNode = this;
-    let curNodes = [curNode];
-    const parts = splitPath(path16);
-    const curNodesQueue = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const part = parts[i];
-      const isLast = i === len - 1;
-      const tempNodes = [];
-      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-        const node = curNodes[j];
-        const nextNode = node.#children[part];
-        if (nextNode) {
-          nextNode.#params = node.#params;
-          if (isLast) {
-            if (nextNode.#children["*"]) {
-              handlerSets.push(
-                ...this.#getHandlerSets(nextNode.#children["*"], method, node.#params)
-              );
-            }
-            handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
-          } else {
-            tempNodes.push(nextNode);
-          }
-        }
-        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
-          const pattern = node.#patterns[k];
-          const params = node.#params === emptyParams ? {} : { ...node.#params };
-          if (pattern === "*") {
-            const astNode = node.#children["*"];
-            if (astNode) {
-              handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
-              astNode.#params = params;
-              tempNodes.push(astNode);
-            }
-            continue;
-          }
-          const [key, name, matcher] = pattern;
-          if (!part && !(matcher instanceof RegExp)) {
-            continue;
-          }
-          const child = node.#children[key];
-          const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp) {
-            const m = matcher.exec(restPathString);
-            if (m) {
-              params[name] = m[0];
-              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-              if (Object.keys(child.#children).length) {
-                child.#params = params;
-                const componentCount = m[0].match(/\//)?.length ?? 0;
-                const targetCurNodes = curNodesQueue[componentCount] ||= [];
-                targetCurNodes.push(child);
-              }
-              continue;
-            }
-          }
-          if (matcher === true || matcher.test(part)) {
-            params[name] = part;
-            if (isLast) {
-              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
-              if (child.#children["*"]) {
-                handlerSets.push(
-                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
-                );
-              }
-            } else {
-              child.#params = params;
-              tempNodes.push(child);
-            }
-          }
-        }
-      }
-      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
-    }
-    if (handlerSets.length > 1) {
-      handlerSets.sort((a, b) => {
-        return a.score - b.score;
-      });
-    }
-    return [handlerSets.map(({ handler, params }) => [handler, params])];
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/router/trie-router/router.js
-var TrieRouter = class {
-  name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node2();
-  }
-  add(method, path16, handler) {
-    const results = checkOptionalParameter(path16);
-    if (results) {
-      for (let i = 0, len = results.length; i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
-      return;
-    }
-    this.#node.insert(method, path16, handler);
-  }
-  match(method, path16) {
-    return this.#node.search(method, path16);
-  }
-};
-// ../../node_modules/.pnpm/hono@4.11.5/node_modules/hono/dist/hono.js
-var Hono2 = class extends Hono {
-  /**
-   * Creates an instance of the Hono class.
-   *
-   * @param options - Optional configuration options for the Hono instance.
-   */
-  constructor(options = {}) {
-    super(options);
-    this.router = options.router ?? new SmartRouter({
-      routers: [new RegExpRouter(), new TrieRouter()]
-    });
-  }
-};
-// src/server/createApp.ts
-import { contextMiddleware, resolveRoutesDir } from "@cloudwerk/core";
-import { setActiveRenderer, getAvailableRenderers } from "@cloudwerk/ui";
-// src/server/registerRoutes.ts
-import * as path8 from "path";
-import {
-  createHandlerAdapter,
-  setRouteConfig,
-  NotFoundError,
-  RedirectError,
-  resolveErrorBoundary,
-  resolveNotFoundBoundary,
-  resolveLoadingBoundary
-} from "@cloudwerk/core";
-import {
-  render,
-  renderStream,
-  renderToStream,
-  generateHydrationScript,
-  generatePreloadHints
-} from "@cloudwerk/ui";
-// src/server/loadHandler.ts
-import * as fs from "fs";
-import * as path from "path";
-import { builtinModules } from "module";
-import { build } from "esbuild";
-import { pathToFileURL } from "url";
-import { validateRouteConfig } from "@cloudwerk/core";
-var moduleCache = /* @__PURE__ */ new Map();
-async function loadRouteHandler(absolutePath, verbose = false) {
-  try {
-    const stat = fs.statSync(absolutePath);
-    const mtime = stat.mtimeMs;
-    const cached = moduleCache.get(absolutePath);
-    if (cached && cached.mtime === mtime) {
-      return cached.module;
-    }
-    const nodeVersion = process.versions.node.split(".")[0];
-    const target = `node${nodeVersion}`;
-    const result = await build({
-      entryPoints: [absolutePath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      platform: "node",
-      target,
-      external: [
-        "@cloudwerk/core",
-        "hono",
-        // Use builtinModules for comprehensive Node.js built-in coverage
-        ...builtinModules,
-        ...builtinModules.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 = findSafeTempDir(absolutePath);
-    const tempFile = path.join(tempDir, `.cloudwerk-route-${cacheKey}.mjs`);
-    fs.writeFileSync(tempFile, code);
-    try {
-      const rawModule = await import(pathToFileURL(tempFile).href);
-      let validatedConfig = void 0;
-      if ("config" in rawModule) {
-        validatedConfig = validateRouteConfig(rawModule.config, absolutePath);
-      }
-      const module = {
-        ...rawModule,
-        config: validatedConfig
-      };
-      moduleCache.set(absolutePath, { module, mtime });
-      return module;
-    } finally {
-      try {
-        fs.unlinkSync(tempFile);
-      } catch {
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to compile route handler at ${absolutePath}: ${message}`);
-  }
-}
-function findSafeTempDir(filePath) {
-  let dir = path.dirname(filePath);
-  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path.basename(p));
-  while (hasSpecialChars(dir)) {
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return dir;
-}
-// src/server/loadMiddleware.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { builtinModules as builtinModules2 } from "module";
-import { build as build2 } from "esbuild";
-import { pathToFileURL as pathToFileURL2 } from "url";
-import { createMiddlewareAdapter } from "@cloudwerk/core";
-var middlewareCache = /* @__PURE__ */ new Map();
-async function loadMiddlewareModule(absolutePath, verbose = false) {
-  if (!fs2.existsSync(absolutePath)) {
-    if (verbose) {
-      console.warn(`Middleware not found: ${absolutePath}`);
-    }
-    return null;
-  }
-  try {
-    const stat = fs2.statSync(absolutePath);
-    const mtime = stat.mtimeMs;
-    const cached = middlewareCache.get(absolutePath);
-    if (cached && cached.mtime === mtime) {
-      return extractMiddleware(cached.module, absolutePath, verbose);
-    }
-    const nodeVersion = process.versions.node.split(".")[0];
-    const target = `node${nodeVersion}`;
-    const result = await build2({
-      entryPoints: [absolutePath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      platform: "node",
-      target,
-      external: [
-        "@cloudwerk/core",
-        "hono",
-        // Use builtinModules for comprehensive Node.js built-in coverage
-        ...builtinModules2,
-        ...builtinModules2.map((m) => `node:${m}`)
-      ],
-      logLevel: verbose ? "warning" : "silent",
-      sourcemap: "inline"
-    });
-    if (!result.outputFiles || result.outputFiles.length === 0) {
-      throw new Error("No output from esbuild");
-    }
-    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const tempDir = findSafeTempDir2(absolutePath);
-    const tempFile = path2.join(tempDir, `.cloudwerk-middleware-${cacheKey}.mjs`);
-    fs2.writeFileSync(tempFile, result.outputFiles[0].text);
-    try {
-      const module = await import(pathToFileURL2(tempFile).href);
-      middlewareCache.set(absolutePath, { module, mtime });
-      return extractMiddleware(module, absolutePath, verbose);
-    } finally {
-      try {
-        fs2.unlinkSync(tempFile);
-      } catch {
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Failed to compile middleware at ${absolutePath}: ${message}`);
-    return null;
-  }
-}
-function extractMiddleware(module, absolutePath, verbose) {
-  const middleware = module.default ?? module.middleware;
-  if (!middleware) {
-    if (verbose) {
-      console.warn(
-        `Middleware at ${absolutePath} must export a default function or named 'middleware' export`
-      );
-    }
-    return null;
-  }
-  if (typeof middleware !== "function") {
-    console.warn(
-      `Middleware in ${absolutePath} must export a function, got ${typeof middleware}`
-    );
-    return null;
-  }
-  return createMiddlewareAdapter(middleware);
-}
-function findSafeTempDir2(filePath) {
-  let dir = path2.dirname(filePath);
-  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path2.basename(p));
-  while (hasSpecialChars(dir)) {
-    const parent = path2.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return dir;
-}
-// src/server/loadPage.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { builtinModules as builtinModules3 } from "module";
-import { build as build3 } from "esbuild";
-import { pathToFileURL as pathToFileURL3 } from "url";
-import { validateRouteConfig as validateRouteConfig2, hasUseClientDirective, generateComponentId, validateComponentBoundaries, handleBoundaryValidationResult } from "@cloudwerk/core";
-var pageModuleCache = /* @__PURE__ */ new Map();
-async function loadPageModule(absolutePath, verbose = false) {
-  try {
-    const stat = fs3.statSync(absolutePath);
-    const mtime = stat.mtimeMs;
-    const cached = pageModuleCache.get(absolutePath);
-    if (cached && cached.mtime === mtime) {
-      return cached.module;
-    }
-    const nodeVersion = process.versions.node.split(".")[0];
-    const target = `node${nodeVersion}`;
-    const result = await build3({
-      entryPoints: [absolutePath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      platform: "node",
-      target,
-      jsx: "automatic",
-      jsxImportSource: "hono/jsx",
-      external: [
-        "@cloudwerk/core",
-        "@cloudwerk/ui",
-        "hono",
-        "hono/jsx",
-        "hono/jsx/dom",
-        "hono/jsx/streaming",
-        "hono/html",
-        // Use builtinModules for comprehensive Node.js built-in coverage
-        ...builtinModules3,
-        ...builtinModules3.map((m) => `node:${m}`)
-      ],
-      logLevel: verbose ? "warning" : "silent",
-      sourcemap: "inline"
-    });
-    if (!result.outputFiles || result.outputFiles.length === 0) {
-      throw new Error("No output from esbuild");
-    }
-    const code = result.outputFiles[0].text;
-    const sourceCode = fs3.readFileSync(absolutePath, "utf-8");
-    const isClientComponent = hasUseClientDirective(sourceCode);
-    const clientComponentId = isClientComponent ? generateComponentId(absolutePath, path3.dirname(absolutePath)) : void 0;
-    const validationResult = validateComponentBoundaries(sourceCode, absolutePath, isClientComponent);
-    handleBoundaryValidationResult(validationResult, absolutePath, { verbose });
-    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const tempDir = findSafeTempDir3(absolutePath);
-    const tempFile = path3.join(tempDir, `.cloudwerk-page-${cacheKey}.mjs`);
-    fs3.writeFileSync(tempFile, code);
-    try {
-      const rawModule = await import(pathToFileURL3(tempFile).href);
-      if (!rawModule.default) {
-        throw new Error("Page must have a default export");
-      }
-      if (typeof rawModule.default !== "function") {
-        throw new Error(
-          `Page default export must be a function (component), got ${typeof rawModule.default}`
-        );
-      }
-      let validatedConfig = void 0;
-      if ("config" in rawModule && rawModule.config !== void 0) {
-        validatedConfig = validateRouteConfig2(rawModule.config, absolutePath);
-      }
-      let validatedLoader = void 0;
-      if ("loader" in rawModule && rawModule.loader !== void 0) {
-        if (typeof rawModule.loader !== "function") {
-          throw new Error(
-            `Page loader export must be a function, got ${typeof rawModule.loader}`
-          );
-        }
-        validatedLoader = rawModule.loader;
-      }
-      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];
-        }
-      }
-      let validatedGenerateStaticParams = void 0;
-      if ("generateStaticParams" in rawModule && rawModule.generateStaticParams !== void 0) {
-        if (typeof rawModule.generateStaticParams !== "function") {
-          throw new Error(
-            `Page generateStaticParams export must be a function, got ${typeof rawModule.generateStaticParams}`
-          );
-        }
-        validatedGenerateStaticParams = rawModule.generateStaticParams;
-      }
-      const module = {
-        default: rawModule.default,
-        config: validatedConfig,
-        loader: validatedLoader,
-        action: validatedAction,
-        ...validatedMethods,
-        isClientComponent,
-        clientComponentId,
-        generateStaticParams: validatedGenerateStaticParams
-      };
-      pageModuleCache.set(absolutePath, { module, mtime });
-      return module;
-    } finally {
-      try {
-        fs3.unlinkSync(tempFile);
-      } catch {
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to compile page at ${absolutePath}: ${message}`);
-  }
-}
-function findSafeTempDir3(filePath) {
-  let dir = path3.dirname(filePath);
-  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path3.basename(p));
-  while (hasSpecialChars(dir)) {
-    const parent = path3.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return dir;
-}
-// src/server/loadLayout.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-import { builtinModules as builtinModules4 } from "module";
-import { build as build4 } from "esbuild";
-import { pathToFileURL as pathToFileURL4 } from "url";
-import { hasUseClientDirective as hasUseClientDirective2, generateComponentId as generateComponentId2, validateComponentBoundaries as validateComponentBoundaries2, handleBoundaryValidationResult as handleBoundaryValidationResult2 } from "@cloudwerk/core";
-var layoutModuleCache = /* @__PURE__ */ new Map();
-async function loadLayoutModule(absolutePath, verbose = false) {
-  try {
-    const stat = fs4.statSync(absolutePath);
-    const mtime = stat.mtimeMs;
-    const cached = layoutModuleCache.get(absolutePath);
-    if (cached && cached.mtime === mtime) {
-      return cached.module;
-    }
-    const nodeVersion = process.versions.node.split(".")[0];
-    const target = `node${nodeVersion}`;
-    const result = await build4({
-      entryPoints: [absolutePath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      platform: "node",
-      target,
-      jsx: "automatic",
-      jsxImportSource: "hono/jsx",
-      external: [
-        "@cloudwerk/core",
-        "@cloudwerk/ui",
-        "hono",
-        "hono/jsx",
-        "hono/jsx/dom",
-        "hono/jsx/streaming",
-        "hono/html",
-        // Use builtinModules for comprehensive Node.js built-in coverage
-        ...builtinModules4,
-        ...builtinModules4.map((m) => `node:${m}`)
-      ],
-      logLevel: verbose ? "warning" : "silent",
-      sourcemap: "inline"
-    });
-    if (!result.outputFiles || result.outputFiles.length === 0) {
-      throw new Error("No output from esbuild");
-    }
-    const code = result.outputFiles[0].text;
-    const sourceCode = fs4.readFileSync(absolutePath, "utf-8");
-    const isClientComponent = hasUseClientDirective2(sourceCode);
-    const clientComponentId = isClientComponent ? generateComponentId2(absolutePath, path4.dirname(absolutePath)) : void 0;
-    const validationResult = validateComponentBoundaries2(sourceCode, absolutePath, isClientComponent);
-    handleBoundaryValidationResult2(validationResult, absolutePath, { verbose });
-    const cacheKey = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const tempDir = findSafeTempDir4(absolutePath);
-    const tempFile = path4.join(tempDir, `.cloudwerk-layout-${cacheKey}.mjs`);
-    fs4.writeFileSync(tempFile, code);
-    try {
-      const rawModule = await import(pathToFileURL4(tempFile).href);
-      if (!rawModule.default) {
-        throw new Error("Layout must have a default export");
-      }
-      if (typeof rawModule.default !== "function") {
-        throw new Error(
-          `Layout default export must be a function (component), got ${typeof rawModule.default}`
-        );
-      }
-      let validatedLoader = void 0;
-      if ("loader" in rawModule && rawModule.loader !== void 0) {
-        if (typeof rawModule.loader !== "function") {
-          throw new Error(
-            `Layout loader export must be a function, got ${typeof rawModule.loader}`
-          );
-        }
-        validatedLoader = rawModule.loader;
-      }
-      const module = {
-        default: rawModule.default,
-        loader: validatedLoader,
-        isClientComponent,
-        clientComponentId
-      };
-      layoutModuleCache.set(absolutePath, { module, mtime });
-      return module;
-    } finally {
-      try {
-        fs4.unlinkSync(tempFile);
-      } catch {
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to compile layout at ${absolutePath}: ${message}`);
-  }
-}
-function findSafeTempDir4(filePath) {
-  let dir = path4.dirname(filePath);
-  const hasSpecialChars = (p) => /\[|\]|\(|\)/.test(path4.basename(p));
-  while (hasSpecialChars(dir)) {
-    const parent = path4.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return dir;
-}
-// src/server/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 = {};
-  const url = new URL(c.req.url);
-  for (const [key, value] of url.searchParams.entries()) {
-    const existing = result[key];
-    if (existing !== void 0) {
-      result[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-// src/server/hydrationManifest.ts
-import * as fs8 from "fs";
-import { createHydrationManifest, addToHydrationManifest, hasUseClientDirective as hasUseClientDirective3, generateComponentId as generateComponentId3 } from "@cloudwerk/core";
-function createManifestTracker(appDir, basePath = "/__cloudwerk") {
-  return {
-    components: /* @__PURE__ */ new Map(),
-    basePath,
-    appDir
-  };
-}
-function trackIfClientComponent(tracker, filePath) {
-  if (tracker.components.has(filePath)) {
-    return true;
-  }
-  try {
-    const content = fs8.readFileSync(filePath, "utf-8");
-    if (hasUseClientDirective3(content)) {
-      const componentId = generateComponentId3(filePath, tracker.appDir);
-      tracker.components.set(filePath, {
-        filePath,
-        componentId,
-        exportName: "default",
-        bundled: false
-      });
-      return true;
-    }
-  } catch (error) {
-    return false;
-  }
-  return false;
-}
-function createRequestScopedManifest(tracker, usedComponentIds) {
-  const manifest = createHydrationManifest(tracker.basePath);
-  for (const component of tracker.components.values()) {
-    if (usedComponentIds.has(component.componentId)) {
-      addToHydrationManifest(
-        manifest,
-        {
-          filePath: component.filePath,
-          componentId: component.componentId,
-          exportName: component.exportName
-        },
-        `${tracker.basePath}/${component.componentId}.js`
-      );
-    }
-  }
-  return manifest;
-}
-function getComponentByIdFromTracker(tracker, componentId) {
-  for (const component of tracker.components.values()) {
-    if (component.componentId === componentId) {
-      return component;
-    }
-  }
-  return void 0;
-}
-// src/server/registerRoutes.ts
-var HTTP_METHODS = [
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS",
-  "HEAD"
-];
-async function injectHydrationScripts(response, hydrationCtx) {
-  if (hydrationCtx.usedComponentIds.size === 0) {
-    return response;
-  }
-  const manifest = createRequestScopedManifest(
-    hydrationCtx.tracker,
-    hydrationCtx.usedComponentIds
-  );
-  const preloadHints = generatePreloadHints(manifest);
-  const hydrationScript = generateHydrationScript(manifest);
-  if (!preloadHints && !hydrationScript) {
-    return response;
-  }
-  const html = await response.text();
-  let modifiedHtml = html;
-  if (preloadHints) {
-    const headEndIndex = modifiedHtml.indexOf("</head>");
-    if (headEndIndex !== -1) {
-      modifiedHtml = modifiedHtml.slice(0, headEndIndex) + "\n" + preloadHints + "\n" + modifiedHtml.slice(headEndIndex);
-    }
-  }
-  if (hydrationScript) {
-    const bodyEndIndex = modifiedHtml.lastIndexOf("</body>");
-    if (bodyEndIndex !== -1) {
-      modifiedHtml = modifiedHtml.slice(0, bodyEndIndex) + "\n" + hydrationScript + "\n" + modifiedHtml.slice(bodyEndIndex);
-    }
-  }
-  return new Response(modifiedHtml, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-function isCloudwerkHandler(fn) {
-  return typeof fn === "function" && fn.length === 2;
-}
-function createConfigMiddleware(config) {
-  return async (_c, next) => {
-    setRouteConfig(config);
-    await next();
-  };
-}
-async function executeLoader(loader, args, c) {
-  try {
-    const data = await Promise.resolve(loader(args));
-    return { data: data ?? {} };
-  } catch (error) {
-    if (error instanceof 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, scanResult, logger, verbose = false, hydrationTracker) {
-  const registeredRoutes = [];
-  for (const route of manifest.routes) {
-    if (route.fileType === "page") {
-      try {
-        logger.debug(`Loading page: ${route.filePath}`);
-        const pageModule = await loadPageModule(route.absolutePath, verbose);
-        const PageComponent = pageModule.default;
-        if (hydrationTracker && pageModule.isClientComponent) {
-          trackIfClientComponent(hydrationTracker, route.absolutePath);
-          if (verbose) {
-            logger.debug(`Tracked client component: ${route.filePath}`);
-          }
-        }
-        const layoutModules = await Promise.all(
-          route.layouts.map((layoutPath) => loadLayoutModule(layoutPath, verbose))
-        );
-        const layouts = layoutModules.map((m) => m.default);
-        if (hydrationTracker) {
-          for (let i = 0; i < layoutModules.length; i++) {
-            if (layoutModules[i].isClientComponent) {
-              trackIfClientComponent(hydrationTracker, route.layouts[i]);
-              if (verbose) {
-                logger.debug(`Tracked client layout: ${route.layouts[i]}`);
-              }
-            }
-          }
-        }
-        const loadingPath = resolveLoadingBoundary(route.filePath, scanResult.loading);
-        let loadingModule = null;
-        if (loadingPath) {
-          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: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`
-              );
-            }
-          }
-        }
-        if (pageModule.config) {
-          app.use(route.urlPattern, createConfigMiddleware(pageModule.config));
-          if (verbose) {
-            logger.info(`Applied page config: ${route.filePath} -> ${route.urlPattern}`);
-          }
-        }
-        app.get(route.urlPattern, async (c) => {
-          const params = c.req.param();
-          const searchParams = parseSearchParams(c);
-          const request = c.req.raw;
-          const pathname = new URL(request.url).pathname;
-          const layoutLoaderData = [];
-          const hydrationCtx = hydrationTracker ? { usedComponentIds: /* @__PURE__ */ new Set(), tracker: hydrationTracker } : null;
-          if (hydrationCtx && pageModule.isClientComponent && pageModule.clientComponentId) {
-            hydrationCtx.usedComponentIds.add(pageModule.clientComponentId);
-          }
-          for (const layoutModule of layoutModules) {
-            if (hydrationCtx && layoutModule.isClientComponent && layoutModule.clientComponentId) {
-              hydrationCtx.usedComponentIds.add(layoutModule.clientComponentId);
-            }
-          }
-          const streamingDisabled = pageModule.config?.streaming === false;
-          const useStreaming = loadingModule && !streamingDisabled;
-          if (useStreaming && loadingModule) {
-            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++) {
-              const layoutModule = layoutModules[index];
-              if (layoutModule.loader) {
-                const result = await executeLoader(layoutModule.loader, loaderArgs, c);
-                if (result.response) {
-                  return result.response;
-                }
-                layoutLoaderData[index] = result.data;
-              } else {
-                layoutLoaderData[index] = {};
-              }
-            }
-            let pageLoaderData = {};
-            if (pageModule.loader) {
-              const result = await executeLoader(pageModule.loader, loaderArgs, c);
-              if (result.response) {
-                return result.response;
-              }
-              pageLoaderData = result.data;
-            }
-            const pageProps = { params, searchParams, ...pageLoaderData };
-            let element = await Promise.resolve(PageComponent(pageProps));
-            for (let i = layouts.length - 1; i >= 0; i--) {
-              const Layout = layouts[i];
-              const layoutProps = {
-                children: element,
-                params,
-                ...layoutLoaderData[i]
-              };
-              element = await Promise.resolve(Layout(layoutProps));
-            }
-            const response = await renderToStream(element);
-            if (hydrationCtx && hydrationCtx.usedComponentIds.size > 0) {
-              return injectHydrationScripts(response, hydrationCtx);
-            }
-            return response;
-          } catch (error) {
-            if (error instanceof NotFoundError) {
-              const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
-              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(
-              `<!DOCTYPE html><html><body><h1>Internal Server Error</h1></body></html>`,
-              500
-            );
-          }
-        });
-        registeredRoutes.push({
-          method: "GET",
-          pattern: route.urlPattern,
-          filePath: route.filePath
-        });
-        logger.debug(`Registered page ${route.urlPattern}`);
-        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 = [];
-              const actionHydrationCtx = hydrationTracker ? { usedComponentIds: /* @__PURE__ */ new Set(), tracker: hydrationTracker } : null;
-              if (actionHydrationCtx && pageModule.isClientComponent && pageModule.clientComponentId) {
-                actionHydrationCtx.usedComponentIds.add(pageModule.clientComponentId);
-              }
-              for (const layoutModule of layoutModules) {
-                if (actionHydrationCtx && layoutModule.isClientComponent && layoutModule.clientComponentId) {
-                  actionHydrationCtx.usedComponentIds.add(layoutModule.clientComponentId);
-                }
-              }
-              try {
-                const actionArgs = { params, request, context: c };
-                const actionResult = await executeAction(actionFn, actionArgs, c);
-                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));
-                }
-                const actionResponse = await renderToStream(element);
-                if (actionHydrationCtx && actionHydrationCtx.usedComponentIds.size > 0) {
-                  return injectHydrationScripts(actionResponse, actionHydrationCtx);
-                }
-                return actionResponse;
-              } catch (error) {
-                if (error instanceof NotFoundError) {
-                  const notFoundPath = resolveNotFoundBoundary(route.filePath, scanResult.notFound);
-                  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}`);
-      }
-      continue;
-    }
-    if (route.fileType !== "route") {
-      logger.debug(`Skipping non-route file: ${route.filePath}`);
-      continue;
+      );
     }
-    try {
-      for (const middlewarePath of route.middleware) {
-        const middlewareHandler = await loadMiddlewareModule(middlewarePath, verbose);
-        if (middlewareHandler) {
-          app.use(route.urlPattern, middlewareHandler);
-          if (verbose) {
-            logger.info(`Applied middleware: ${path8.basename(middlewarePath)} -> ${route.urlPattern}`);
-          }
-        }
-      }
-      logger.debug(`Loading route handler: ${route.filePath}`);
-      const module = await loadRouteHandler(route.absolutePath, verbose);
-      if (module.config) {
-        app.use(route.urlPattern, createConfigMiddleware(module.config));
-        if (verbose) {
-          logger.info(`Applied route config: ${route.filePath} -> ${route.urlPattern}`);
-        }
-      }
-      for (const method of HTTP_METHODS) {
-        const handler = module[method];
-        if (handler && typeof handler === "function") {
-          registerMethod(app, method, route.urlPattern, handler);
-          registeredRoutes.push({
-            method,
-            pattern: route.urlPattern,
-            filePath: route.filePath
-          });
-          logger.debug(`Registered ${method} ${route.urlPattern}`);
-        }
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to load route ${route.filePath}: ${message}`);
+    if (remainingCount > 0) {
+      console.log(pc.dim(`    ... and ${remainingCount} more routes`));
     }
+    console.log();
   }
-  return registeredRoutes;
+  console.log(pc.dim(`  Ready in ${startupTime}ms`));
+  console.log();
 }
-function registerMethod(app, method, pattern, handler) {
-  const h = isCloudwerkHandler(handler) ? createHandlerAdapter(handler) : handler;
-  switch (method) {
+function getMethodColor(method) {
+  switch (method.toUpperCase()) {
     case "GET":
-      app.get(pattern, h);
-      break;
+      return pc.green;
     case "POST":
-      app.post(pattern, h);
-      break;
+      return pc.blue;
     case "PUT":
-      app.put(pattern, h);
-      break;
+      return pc.yellow;
     case "PATCH":
-      app.patch(pattern, h);
-      break;
+      return pc.magenta;
     case "DELETE":
-      app.delete(pattern, h);
-      break;
+      return pc.red;
     case "OPTIONS":
-      app.options(pattern, h);
-      break;
+      return pc.cyan;
     case "HEAD":
-      app.on("HEAD", [pattern], h);
-      break;
-  }
-}
-// src/server/hydrationRoutes.ts
-import {
-  generateHydrationRuntime as generateHydrationRuntime2,
-  generateReactHydrationRuntime as generateReactHydrationRuntime2
-} from "@cloudwerk/ui";
-// src/server/clientBundle.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
-import { createRequire } from "module";
-import { build as build8 } from "esbuild";
-import { generateComponentId as generateComponentId4, createHydrationManifest as createHydrationManifest2, addToHydrationManifest as addToHydrationManifest2 } from "@cloudwerk/core";
-import { generateHydrationRuntime, generateReactHydrationRuntime } from "@cloudwerk/ui";
-var require2 = createRequire(import.meta.url);
-var honoMainPath = require2.resolve("hono");
-function findNodeModulesDir(filePath) {
-  let dir = filePath;
-  while (dir !== path9.dirname(dir)) {
-    dir = path9.dirname(dir);
-    if (path9.basename(dir) === "node_modules") {
-      return dir;
-    }
+      return pc.gray;
+    default:
+      return pc.white;
   }
-  return path9.join(path9.dirname(filePath), "..", "..");
 }
-var nodeModulesPath = findNodeModulesDir(honoMainPath);
-var bundleCache = /* @__PURE__ */ new Map();
-async function generateBundleOnDemand(componentPath, appDir, options = {}) {
-  const { renderer = "hono-jsx" } = options;
-  const cacheKey = `${componentPath}:${renderer}`;
-  const stat = fs9.statSync(componentPath);
-  const cached = bundleCache.get(cacheKey);
-  if (cached && cached.mtime === stat.mtimeMs) {
-    return {
-      content: cached.content,
-      componentId: generateComponentId4(componentPath, appDir)
-    };
-  }
-  const jsxImportSource = renderer === "react" ? "react" : "hono/jsx/dom";
-  const result = await build8({
-    entryPoints: [componentPath],
-    bundle: true,
-    write: false,
-    format: "esm",
-    platform: "browser",
-    target: ["es2020", "chrome80", "firefox80", "safari14"],
-    jsx: "automatic",
-    jsxImportSource,
-    minify: false,
-    sourcemap: "inline",
-    define: {
-      "process.env.NODE_ENV": JSON.stringify("development")
-    },
-    logLevel: "silent",
-    // Resolve hono/react from the package's node_modules
-    nodePaths: [nodeModulesPath]
-  });
-  if (!result.outputFiles || result.outputFiles.length === 0) {
-    throw new Error("No output from esbuild");
+function printError(message, suggestion) {
+  console.log();
+  console.log(pc.red("Error: ") + message);
+  if (suggestion) {
+    console.log();
+    console.log(pc.dim("  " + suggestion));
   }
-  const content = result.outputFiles[0].text;
-  const componentId = generateComponentId4(componentPath, appDir);
-  bundleCache.set(cacheKey, {
-    content,
-    mtime: stat.mtimeMs,
-    bundlePath: `/__cloudwerk/${componentId}.js`
-  });
-  return { content, componentId };
+  console.log();
 }
-// src/server/hydrationRoutes.ts
-var runtimeCache = /* @__PURE__ */ new Map();
-function registerHydrationRoutes(app, options) {
-  const { tracker, appDir, logger, verbose = false, renderer = "hono-jsx" } = options;
-  app.get("/__cloudwerk/runtime.js", (c) => {
-    if (verbose) {
-      logger.debug("Serving Hono JSX hydration runtime");
-    }
-    let runtime = runtimeCache.get("hono-jsx");
-    if (!runtime) {
-      runtime = generateHydrationRuntime2();
-      runtimeCache.set("hono-jsx", runtime);
-    }
-    return c.text(runtime, 200, {
-      "Content-Type": "application/javascript; charset=utf-8",
-      "Cache-Control": "public, max-age=31536000, immutable"
-    });
-  });
-  app.get("/__cloudwerk/react-runtime.js", (c) => {
-    if (verbose) {
-      logger.debug("Serving React hydration runtime");
-    }
-    let runtime = runtimeCache.get("react");
-    if (!runtime) {
-      runtime = generateReactHydrationRuntime2();
-      runtimeCache.set("react", runtime);
-    }
-    return c.text(runtime, 200, {
-      "Content-Type": "application/javascript; charset=utf-8",
-      "Cache-Control": "public, max-age=31536000, immutable"
-    });
-  });
-  app.get("/__cloudwerk/:componentId{.+\\.js$}", async (c) => {
-    const componentIdWithExt = c.req.param("componentId");
-    const componentId = componentIdWithExt.replace(/\.js$/, "");
-    if (verbose) {
-      logger.debug(`Serving component bundle: ${componentId}`);
-    }
-    const component = getComponentByIdFromTracker(tracker, componentId);
-    if (!component) {
-      logger.warn(`[Cloudwerk] Component not found: ${componentId}`);
-      return c.text(`// Component not found: ${componentId}`, 404, {
-        "Content-Type": "application/javascript; charset=utf-8"
-      });
-    }
-    try {
-      const { content } = await generateBundleOnDemand(
-        component.filePath,
-        appDir,
-        { renderer }
-      );
-      return c.text(content, 200, {
-        "Content-Type": "application/javascript; charset=utf-8",
-        "Cache-Control": "no-cache"
-        // Dev mode - always check for updates
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error(`[Cloudwerk] Failed to bundle component ${componentId}: ${message}`);
-      return c.text(`// Bundle error: ${message}`, 500, {
-        "Content-Type": "application/javascript; charset=utf-8"
-      });
-    }
-  });
-  if (verbose) {
-    logger.info("Registered hydration routes at /__cloudwerk/*");
-  }
-}
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
 // src/constants.ts
 var DEFAULT_PORT = 3e3;
 var DEFAULT_HOST = "localhost";
 var SHUTDOWN_TIMEOUT_MS = 5e3;
-var HTTP_STATUS = {
-  NOT_FOUND: 404,
-  INTERNAL_SERVER_ERROR: 500
-};
-// src/server/createApp.ts
-async function createApp(manifest, scanResult, config, logger, verbose = false) {
-  const rendererName = config.ui?.renderer ?? "hono-jsx";
-  try {
-    setActiveRenderer(rendererName);
-    if (verbose) {
-      logger.info(`Using UI renderer: ${rendererName}`);
-    }
-  } catch (error) {
-    const available = getAvailableRenderers().join(", ");
-    throw new Error(
-      `Failed to initialize UI renderer "${rendererName}". Available renderers: ${available}.`,
-      { cause: error }
-    );
-  }
-  const app = new Hono2({
-    strict: false
-  });
-  app.use("*", contextMiddleware());
-  if (verbose) {
-    app.use("*", async (c, next) => {
-      const start = Date.now();
-      await next();
-      const duration = Date.now() - start;
-      logRequest(c.req.method, c.req.path, c.res.status, duration);
-    });
-  }
-  if (config.globalMiddleware && config.globalMiddleware.length > 0) {
-    for (const middleware of config.globalMiddleware) {
-      app.use("*", middleware);
-    }
-  }
-  const appDir = resolveRoutesDir(config, manifest.rootDir);
-  const hydrationTracker = createManifestTracker(appDir);
-  registerHydrationRoutes(app, {
-    tracker: hydrationTracker,
-    appDir,
-    logger,
-    verbose,
-    renderer: rendererName === "react" ? "react" : "hono-jsx"
-  });
-  const routes = await registerRoutes(app, manifest, scanResult, logger, verbose, hydrationTracker);
-  app.notFound((c) => {
-    return c.json(
-      {
-        error: "Not Found",
-        path: c.req.path,
-        method: c.req.method
-      },
-      HTTP_STATUS.NOT_FOUND
-    );
-  });
-  app.onError((err, c) => {
-    logger.error(`Request error: ${err.message}`);
-    return c.json(
-      {
-        error: "Internal Server Error",
-        message: err.message,
-        stack: err.stack
-      },
-      HTTP_STATUS.INTERNAL_SERVER_ERROR
-    );
-  });
-  return { app, routes };
-}
-// src/version.ts
-import { createRequire as createRequire2 } from "module";
-var require3 = createRequire2(import.meta.url);
-var pkg = require3("../package.json");
-var VERSION = pkg.version;
 // src/commands/dev.ts
 async function dev(pathArg, options) {
@@ -3729,8 +121,8 @@ async function dev(pathArg, options) {
   const verbose = options.verbose ?? false;
   const logger = createLogger(verbose);
   try {
-    const cwd = pathArg ? path10.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs10.existsSync(cwd)) {
+    const cwd = pathArg ? path.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -3738,47 +130,6 @@ async function dev(pathArg, options) {
       );
     }
     logger.debug(`Working directory: ${cwd}`);
-    logger.debug(`Loading configuration...`);
-    const config = await loadConfig(cwd);
-    logger.debug(`Config loaded: routesDir=${config.routesDir}, extensions=${config.extensions.join(", ")}`);
-    const routesDir = resolveRoutesDir2(config, cwd);
-    logger.debug(`Routes directory: ${routesDir}`);
-    if (!fs10.existsSync(routesDir)) {
-      throw new CliError(
-        `Routes directory does not exist: ${routesDir}`,
-        "ENOENT",
-        `Create the "${config.routesDir}" directory or update routesDir in cloudwerk.config.ts`
-      );
-    }
-    logger.debug(`Scanning routes...`);
-    const scanResult = await scanRoutes(routesDir, config);
-    logger.debug(`Found ${scanResult.routes.length} route files`);
-    logger.debug(`Building route manifest...`);
-    const manifest = buildRouteManifest(
-      scanResult,
-      routesDir,
-      resolveLayouts,
-      resolveMiddleware
-    );
-    if (hasErrors(manifest)) {
-      const errorMessages = formatErrors(manifest.errors);
-      logger.error(errorMessages);
-      throw new CliError(
-        "Route validation failed",
-        "VALIDATION_ERROR",
-        "Fix the errors above and try again."
-      );
-    }
-    if (manifest.warnings.length > 0) {
-      const warningMessages = formatWarnings(manifest.warnings);
-      logger.warn(warningMessages);
-    }
-    if (manifest.routes.length === 0) {
-      logger.warn(`No routes found in ${config.routesDir}`);
-      logger.warn(`Create a route.ts file to get started.`);
-    }
-    logger.debug(`Creating Hono app...`);
-    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(
@@ -3787,37 +138,56 @@ async function dev(pathArg, options) {
         "Port must be a number between 1 and 65535"
       );
     }
-    logger.debug(`Starting server on port ${port}...`);
-    const host = options.host;
-    const server = serve({
-      fetch: app.fetch,
-      port,
-      hostname: host
-    });
-    server.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        printError(
-          `Port ${port} is already in use`,
-          `Try using a different port:
-    cloudwerk dev --port ${port + 1}`
-        );
-        process.exit(1);
-      } else {
-        printError(err.message);
-        process.exit(1);
-      }
-    });
-    await new Promise((resolve3) => {
-      server.on("listening", resolve3);
-    });
+    const viteConfig = {
+      root: cwd,
+      mode: "development",
+      server: {
+        port,
+        host: options.host,
+        strictPort: true
+      },
+      plugins: [
+        cloudwerk({
+          verbose
+        }),
+        devServer({
+          entry: "virtual:cloudwerk/server-entry"
+        })
+      ],
+      // Suppress Vite's default startup message - we'll print our own
+      logLevel: verbose ? "info" : "warn",
+      clearScreen: false
+    };
+    logger.debug(`Starting Vite dev server...`);
+    const server = await createServer(viteConfig);
+    await server.listen();
+    const resolvedPort = server.config.server.port ?? port;
+    const resolvedHost = server.config.server.host === true ? "0.0.0.0" : server.config.server.host ?? "localhost";
+    const localHost = resolvedHost === "0.0.0.0" ? "localhost" : resolvedHost;
+    const localUrl = `http://${localHost}:${resolvedPort}/`;
+    const networkUrl = resolvedHost === "0.0.0.0" ? getNetworkUrl(resolvedPort) : void 0;
     const startupTime = Date.now() - startTime;
-    const localUrl = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}/`;
-    const networkUrl = host === "0.0.0.0" ? getNetworkUrl(port) : void 0;
+    const routes = [];
+    try {
+      const manifestModule = await server.ssrLoadModule("virtual:cloudwerk/manifest");
+      const manifest = manifestModule.default;
+      if (manifest?.routes) {
+        for (const route of manifest.routes) {
+          if (route.fileType === "page") {
+            routes.push({ method: "GET", pattern: route.urlPattern });
+          } else if (route.fileType === "route") {
+            routes.push({ method: "ALL", pattern: route.urlPattern });
+          }
+        }
+      }
+    } catch {
+      logger.debug("Could not load route manifest for startup banner");
+    }
     printStartupBanner(
       VERSION,
       localUrl,
       networkUrl,
-      routes.map((r) => ({ method: r.method, pattern: r.pattern })),
+      routes,
       startupTime
     );
     setupGracefulShutdown(server, logger);
@@ -3827,6 +197,15 @@ async function dev(pathArg, options) {
       process.exit(1);
     }
     if (error instanceof Error) {
+      if (error.code === "EADDRINUSE") {
+        const port = parseInt(options.port, 10);
+        printError(
+          `Port ${port} is already in use`,
+          `Try using a different port:
+    cloudwerk dev --port ${port + 1}`
+        );
+        process.exit(1);
+      }
       printError(error.message);
       if (verbose && error.stack) {
         console.log(error.stack);
@@ -3851,185 +230,55 @@ function getNetworkUrl(port) {
   return void 0;
 }
 function setupGracefulShutdown(server, logger) {
-  const shutdown = () => {
+  const shutdown = async () => {
     console.log();
     logger.info("Shutting down...");
-    server.close(() => {
-      logger.info("Server closed");
-      process.exit(0);
-    });
+    await server.close();
+    logger.info("Server closed");
+    process.exit(0);
+  };
+  const forceShutdown = () => {
     setTimeout(() => {
       logger.warn("Forcing shutdown...");
       process.exit(0);
     }, SHUTDOWN_TIMEOUT_MS);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-// src/commands/build.ts
-import * as path12 from "path";
-import * as fs12 from "fs";
-import {
-  loadConfig as loadConfig2,
-  scanRoutes as scanRoutes2,
-  buildRouteManifest as buildRouteManifest2,
-  resolveLayouts as resolveLayouts2,
-  resolveMiddleware as resolveMiddleware2,
-  resolveRoutesDir as resolveRoutesDir3,
-  hasErrors as hasErrors2,
-  formatErrors as formatErrors2,
-  formatWarnings as formatWarnings2
-} from "@cloudwerk/core";
-// src/server/ssg.ts
-import * as fs11 from "fs/promises";
-import * as path11 from "path";
-async function getStaticRoutesAsync(manifest, logger) {
-  const staticRoutes = [];
-  for (const route of manifest.routes) {
-    if (route.fileType !== "page") {
-      continue;
-    }
-    try {
-      const module = await loadPageModule(route.absolutePath);
-      if (module.config?.rendering === "static") {
-        staticRoutes.push({ route, module });
-        logger?.debug(`Found static route: ${route.urlPattern}`);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger?.warn(`Failed to load page module for ${route.urlPattern}: ${errorMessage}`);
-    }
-  }
-  return staticRoutes;
-}
-function hasDynamicSegments(segments) {
-  return segments.some(
-    (segment) => segment.type === "dynamic" || segment.type === "catchAll" || segment.type === "optionalCatchAll"
-  );
-}
-function interpolatePath(urlPattern, params) {
-  let result = urlPattern;
-  for (const [key, value] of Object.entries(params)) {
-    const encodedValue = encodeURIComponent(value);
-    result = result.replace(`:${key}`, encodedValue);
-    result = result.replace(`*${key}`, encodedValue);
-  }
-  return result;
-}
-function urlPathToOutputFile(urlPath) {
-  let normalizedPath = urlPath;
-  if (normalizedPath.startsWith("/")) {
-    normalizedPath = normalizedPath.slice(1);
-  }
-  if (normalizedPath === "") {
-    return "index.html";
-  }
-  return path11.join(normalizedPath, "index.html");
-}
-async function generateStaticSite(app, manifest, outputDir, logger, verbose = false) {
-  const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
-  const results = [];
-  await fs11.mkdir(outputDir, { recursive: true });
-  for (const { route, module } of staticRoutes) {
-    try {
-      const urlPaths = await getUrlPathsForRouteWithModule(route, module, verbose ? logger : void 0);
-      for (const urlPath of urlPaths) {
-        const result = await generateStaticPage(app, urlPath, outputDir, logger, verbose);
-        results.push(result);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to generate static pages for ${route.urlPattern}: ${errorMessage}`);
-      results.push({
-        urlPath: route.urlPattern,
-        outputFile: urlPathToOutputFile(route.urlPattern),
-        success: false,
-        error: errorMessage
-      });
-    }
-  }
-  const successCount = results.filter((r) => r.success).length;
-  const failureCount = results.filter((r) => !r.success).length;
-  return {
-    totalPages: results.length,
-    successCount,
-    failureCount,
-    routes: results,
-    outputDir
-  };
-}
-async function getUrlPathsForRouteWithModule(route, module, logger) {
-  if (!hasDynamicSegments(route.segments)) {
-    return [route.urlPattern];
-  }
-  if (!module.generateStaticParams) {
-    logger?.warn(
-      `Static route ${route.urlPattern} has dynamic segments but no generateStaticParams export. Skipping.`
-    );
-    return [];
-  }
-  const paramsList = await module.generateStaticParams({});
-  if (!Array.isArray(paramsList)) {
-    throw new Error(
-      `generateStaticParams must return an array, got ${typeof paramsList}`
-    );
-  }
-  const urlPaths = paramsList.map((params) => {
-    if (typeof params !== "object" || params === null) {
-      throw new Error(
-        `generateStaticParams must return array of objects, got ${typeof params}`
-      );
-    }
-    return interpolatePath(route.urlPattern, params);
+  process.on("SIGINT", async () => {
+    forceShutdown();
+    await shutdown();
+  });
+  process.on("SIGTERM", async () => {
+    forceShutdown();
+    await shutdown();
   });
-  logger?.debug(`Generated ${urlPaths.length} paths for ${route.urlPattern}`);
-  return urlPaths;
-}
-async function generateStaticPage(app, urlPath, outputDir, logger, verbose) {
-  const outputFile = urlPathToOutputFile(urlPath);
-  const outputPath = path11.join(outputDir, outputFile);
-  try {
-    const url = `http://localhost${urlPath}`;
-    const request = new Request(url, { method: "GET" });
-    const response = await app.fetch(request);
-    if (!response.ok) {
-      throw new Error(`Request failed with status ${response.status}`);
-    }
-    const html = await response.text();
-    await fs11.mkdir(path11.dirname(outputPath), { recursive: true });
-    await fs11.writeFile(outputPath, html, "utf-8");
-    if (verbose) {
-      logger.debug(`Generated: ${outputFile}`);
-    }
-    return {
-      urlPath,
-      outputFile,
-      success: true
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error(`Failed to generate ${urlPath}: ${errorMessage}`);
-    return {
-      urlPath,
-      outputFile,
-      success: false,
-      error: errorMessage
-    };
-  }
 }
 // src/commands/build.ts
+import { builtinModules } from "module";
+import * as path2 from "path";
+import * as fs2 from "fs";
+import { build as viteBuild } from "vite";
+import cloudwerk2, { generateServerEntry } from "@cloudwerk/vite-plugin";
+import {
+  scanRoutes,
+  buildRouteManifest,
+  resolveLayouts,
+  resolveMiddleware,
+  loadConfig,
+  resolveRoutesPath
+} from "@cloudwerk/core/build";
 var DEFAULT_OUTPUT_DIR = "./dist";
-var STATIC_SUBDIR = "static";
-async function build9(pathArg, options) {
+var BUILD_TEMP_DIR = ".cloudwerk-build";
+async function build(pathArg, options) {
   const startTime = Date.now();
   const verbose = options.verbose ?? false;
+  const minify = options.minify ?? true;
+  const sourcemap = options.sourcemap ?? false;
   const logger = createLogger(verbose);
+  let tempDir = null;
   try {
-    const cwd = pathArg ? path12.resolve(process.cwd(), pathArg) : process.cwd();
-    if (!fs12.existsSync(cwd)) {
+    const cwd = pathArg ? path2.resolve(process.cwd(), pathArg) : process.cwd();
+    if (!fs2.existsSync(cwd)) {
       throw new CliError(
         `Directory does not exist: ${cwd}`,
         "ENOENT",
@@ -4037,80 +286,134 @@ async function build9(pathArg, options) {
       );
     }
     logger.debug(`Working directory: ${cwd}`);
-    logger.debug(`Loading configuration...`);
-    const config = await loadConfig2(cwd);
-    logger.debug(`Config loaded: routesDir=${config.routesDir}, extensions=${config.extensions.join(", ")}`);
-    const routesDir = resolveRoutesDir3(config, cwd);
-    logger.debug(`Routes directory: ${routesDir}`);
-    if (!fs12.existsSync(routesDir)) {
-      throw new CliError(
-        `Routes directory does not exist: ${routesDir}`,
-        "ENOENT",
-        `Create the "${config.routesDir}" directory or update routesDir in cloudwerk.config.ts`
-      );
+    const outputBase = options.output ?? DEFAULT_OUTPUT_DIR;
+    const outputDir = path2.isAbsolute(outputBase) ? outputBase : path2.resolve(cwd, outputBase);
+    if (fs2.existsSync(outputDir)) {
+      logger.debug(`Cleaning output directory: ${outputDir}`);
+      fs2.rmSync(outputDir, { recursive: true, force: true });
     }
-    logger.debug(`Scanning routes...`);
-    const scanResult = await scanRoutes2(routesDir, config);
-    logger.debug(`Found ${scanResult.routes.length} route files`);
-    logger.debug(`Building route manifest...`);
-    const manifest = buildRouteManifest2(
+    fs2.mkdirSync(outputDir, { recursive: true });
+    logger.info(`Building to ${outputDir}...`);
+    tempDir = path2.join(cwd, BUILD_TEMP_DIR);
+    if (!fs2.existsSync(tempDir)) {
+      fs2.mkdirSync(tempDir, { recursive: true });
+    }
+    const cloudwerkConfig = await loadConfig(cwd);
+    const appDir = cloudwerkConfig.appDir;
+    const routesDir = cloudwerkConfig.routesDir ?? "routes";
+    const routesPath = resolveRoutesPath(routesDir, appDir, cwd);
+    logger.debug(`Scanning routes from: ${routesPath}`);
+    const scanResult = await scanRoutes(routesPath, {
+      extensions: cloudwerkConfig.extensions
+    });
+    const manifest = buildRouteManifest(
       scanResult,
-      routesDir,
-      resolveLayouts2,
-      resolveMiddleware2
+      routesPath,
+      resolveLayouts,
+      resolveMiddleware
     );
-    if (hasErrors2(manifest)) {
-      const errorMessages = formatErrors2(manifest.errors);
-      logger.error(errorMessages);
-      throw new CliError(
-        "Route validation failed",
-        "VALIDATION_ERROR",
-        "Fix the errors above and try again."
-      );
-    }
-    if (manifest.warnings.length > 0) {
-      const warningMessages = formatWarnings2(manifest.warnings);
-      logger.warn(warningMessages);
-    }
-    if (manifest.routes.length === 0) {
-      logger.warn(`No routes found in ${config.routesDir}`);
-      logger.warn(`Create a route.ts file to get started.`);
+    logger.debug(`Found ${manifest.routes.length} routes`);
+    const renderer = cloudwerkConfig.ui?.renderer ?? "hono-jsx";
+    const serverEntryCode = generateServerEntry(manifest, scanResult, {
+      appDir,
+      routesDir,
+      config: cloudwerkConfig,
+      serverEntry: null,
+      clientEntry: null,
+      verbose,
+      hydrationEndpoint: "/__cloudwerk",
+      renderer,
+      root: cwd
+    });
+    const tempEntryPath = path2.join(tempDir, "_server-entry.ts");
+    fs2.writeFileSync(tempEntryPath, serverEntryCode);
+    logger.debug(`Generated temp entry: ${tempEntryPath}`);
+    logger.debug(`Building client assets...`);
+    const clientConfig = {
+      root: cwd,
+      mode: "production",
+      logLevel: verbose ? "info" : "warn",
+      plugins: [
+        cloudwerk2({ verbose })
+      ],
+      build: {
+        outDir: path2.join(outputDir, "static"),
+        emptyOutDir: true,
+        minify: minify ? "esbuild" : false,
+        sourcemap,
+        rollupOptions: {
+          input: "virtual:cloudwerk/client-entry",
+          output: {
+            entryFileNames: "__cloudwerk/client.js",
+            chunkFileNames: "__cloudwerk/[name]-[hash].js",
+            assetFileNames: "__cloudwerk/[name]-[hash][extname]"
+          }
+        }
+      }
+    };
+    try {
+      await viteBuild(clientConfig);
+      logger.debug(`Client assets built successfully`);
+    } catch (error) {
+      if (verbose) {
+        logger.debug(`Client build skipped or failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
     }
-    const outputBase = options.output ?? DEFAULT_OUTPUT_DIR;
-    const outputDir = path12.isAbsolute(outputBase) ? outputBase : path12.resolve(cwd, outputBase);
-    logger.info(`Building to ${outputDir}...`);
-    if (options.ssg) {
-      logger.debug(`Scanning for static routes...`);
-      const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
-      if (staticRoutes.length === 0) {
-        logger.warn(`No static routes found. Add rendering: 'static' to route configs to enable SSG.`);
-      } else {
-        logger.info(`Found ${staticRoutes.length} static route(s)`);
-        logger.debug(`Creating Hono app for SSG...`);
-        const { app } = await createApp(manifest, scanResult, config, logger, verbose);
-        const staticOutputDir = path12.join(outputDir, STATIC_SUBDIR);
-        logger.info(`Generating static pages to ${staticOutputDir}...`);
-        const ssgStartTime = Date.now();
-        const result = await generateStaticSite(app, manifest, staticOutputDir, logger, verbose);
-        const ssgDuration = Date.now() - ssgStartTime;
-        printSSGResults(result, logger, ssgDuration);
-        if (result.failureCount > 0) {
-          throw new CliError(
-            `Failed to generate ${result.failureCount} static page(s)`,
-            "SSG_ERROR",
-            "Check the errors above and fix any issues."
-          );
+    logger.debug(`Building server bundle...`);
+    const serverConfig = {
+      root: cwd,
+      mode: "production",
+      logLevel: verbose ? "info" : "warn",
+      plugins: [
+        cloudwerk2({ verbose })
+      ],
+      build: {
+        outDir: outputDir,
+        emptyOutDir: false,
+        // Don't clear - client assets are already there
+        minify: minify ? "esbuild" : false,
+        sourcemap,
+        ssr: true,
+        rollupOptions: {
+          input: tempEntryPath,
+          // Externalize Node.js builtins (polyfilled by nodejs_compat in Workers)
+          external: [...builtinModules, /^node:/],
+          output: {
+            entryFileNames: "index.js"
+          }
         }
+      },
+      ssr: {
+        target: "webworker",
+        noExternal: true
+        // Bundle all dependencies
+      },
+      resolve: {
+        // Prefer browser/worker fields in package.json
+        conditions: ["workerd", "worker", "browser", "import", "module", "default"]
       }
-    } else {
-      logger.debug(`Scanning for static routes...`);
-      const staticRoutes = await getStaticRoutesAsync(manifest, verbose ? logger : void 0);
-      if (staticRoutes.length > 0) {
-        logger.info(`Found ${staticRoutes.length} static route(s). Use --ssg to generate static pages.`);
+    };
+    await viteBuild(serverConfig);
+    logger.debug(`Server bundle built successfully`);
+    const buildDuration = Date.now() - startTime;
+    const serverBundlePath = path2.join(outputDir, "index.js");
+    const serverSize = fs2.existsSync(serverBundlePath) ? fs2.statSync(serverBundlePath).size : 0;
+    const clientDir = path2.join(outputDir, "static", "__cloudwerk");
+    let clientSize = 0;
+    if (fs2.existsSync(clientDir)) {
+      const clientFiles = fs2.readdirSync(clientDir);
+      for (const file of clientFiles) {
+        const filePath = path2.join(clientDir, file);
+        const stat = fs2.statSync(filePath);
+        if (stat.isFile()) {
+          clientSize += stat.size;
+        }
       }
     }
-    const buildTime = Date.now() - startTime;
-    logger.success(`Build completed in ${buildTime}ms`);
+    console.log();
+    printBuildSummary(serverSize, clientSize, buildDuration, logger);
+    console.log();
+    logger.success(`Build completed in ${buildDuration}ms`);
   } catch (error) {
     if (error instanceof CliError) {
       printError(error.message, error.suggestion);
@@ -4125,37 +428,41 @@ async function build9(pathArg, options) {
     }
     printError(String(error));
     process.exit(1);
+  } finally {
+    if (tempDir && fs2.existsSync(tempDir)) {
+      try {
+        fs2.rmSync(tempDir, { recursive: true, force: true });
+        if (verbose) {
+          logger.debug(`Cleaned up temp directory: ${tempDir}`);
+        }
+      } catch {
+      }
+    }
   }
 }
-function printSSGResults(result, logger, duration) {
-  console.log();
-  logger.log("Static Site Generation Results:");
-  logger.log(`  Total pages: ${result.totalPages}`);
-  logger.log(`  Generated: ${result.successCount}`);
-  if (result.failureCount > 0) {
-    logger.log(`  Failed: ${result.failureCount}`);
+function printBuildSummary(serverSize, clientSize, buildDuration, logger) {
+  logger.log("Build Output:");
+  logger.log("");
+  logger.log("  Server:");
+  logger.log(`    Bundle:     ${formatSize(serverSize)}`);
+  logger.log("");
+  if (clientSize > 0) {
+    logger.log("  Client:");
+    logger.log(`    Total:      ${formatSize(clientSize)}`);
+    logger.log("");
   }
-  logger.log(`  Output: ${result.outputDir}`);
-  logger.log(`  Duration: ${duration}ms`);
-  const pagesToShow = result.routes.filter((r) => r.success).slice(0, 10);
-  if (pagesToShow.length > 0) {
-    console.log();
-    logger.log("Generated pages:");
-    for (const page of pagesToShow) {
-      logger.log(`  ${page.urlPath} -> ${page.outputFile}`);
-    }
-    if (result.successCount > 10) {
-      logger.log(`  ... and ${result.successCount - 10} more`);
-    }
+  const totalSize = serverSize + clientSize;
+  logger.log(`  Total:        ${formatSize(totalSize)}`);
+  logger.log(`  Duration:     ${buildDuration}ms`);
+}
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
   }
-  const failedPages = result.routes.filter((r) => !r.success);
-  if (failedPages.length > 0) {
-    console.log();
-    logger.error("Failed pages:");
-    for (const page of failedPages) {
-      logger.error(`  ${page.urlPath}: ${page.error}`);
-    }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
   }
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
 }
 // src/commands/config.ts
@@ -4163,9 +470,9 @@ import * as readline from "readline";
 import pc2 from "picocolors";
 // src/utils/configWriter.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
-import { loadConfig as loadConfig3 } from "@cloudwerk/core";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { loadConfig as loadConfig2 } from "@cloudwerk/core/build";
 var CONFIG_FILE_NAMES = [
   "cloudwerk.config.ts",
   "cloudwerk.config.js",
@@ -4173,8 +480,8 @@ var CONFIG_FILE_NAMES = [
 ];
 function findConfigFile(cwd) {
   for (const filename of CONFIG_FILE_NAMES) {
-    const configPath = path13.join(cwd, filename);
-    if (fs13.existsSync(configPath)) {
+    const configPath = path3.join(cwd, filename);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -4185,7 +492,7 @@ function readCloudwerkConfig(cwd) {
   if (!configPath) {
     return {};
   }
-  const content = fs13.readFileSync(configPath, "utf-8");
+  const content = fs3.readFileSync(configPath, "utf-8");
   return parseConfigContent(content);
 }
 function parseConfigContent(content) {
@@ -4206,16 +513,16 @@ function parseConfigContent(content) {
 function writeCloudwerkConfig(cwd, updates) {
   const configPath = findConfigFile(cwd);
   if (!configPath) {
-    const newConfigPath = path13.join(cwd, "cloudwerk.config.ts");
+    const newConfigPath = path3.join(cwd, "cloudwerk.config.ts");
     const content2 = generateMinimalConfig(updates);
-    fs13.writeFileSync(newConfigPath, content2, "utf-8");
+    fs3.writeFileSync(newConfigPath, content2, "utf-8");
     return true;
   }
-  let content = fs13.readFileSync(configPath, "utf-8");
+  let content = fs3.readFileSync(configPath, "utf-8");
   if (updates.renderer !== void 0) {
     content = updateRenderer(content, updates.renderer);
   }
-  fs13.writeFileSync(configPath, content, "utf-8");
+  fs3.writeFileSync(configPath, content, "utf-8");
   return true;
 }
 function updateRenderer(content, renderer) {
@@ -4259,9 +566,9 @@ function addUiSection(content, renderer) {
 function detectIndentation(lines, closingLineIndex) {
   for (let i = closingLineIndex - 1; i >= 0; i--) {
     const line = lines[i];
-    const match2 = line.match(/^(\s+)\S/);
-    if (match2) {
-      return match2[1];
+    const match = line.match(/^(\s+)\S/);
+    if (match) {
+      return match[1];
     }
   }
   return "  ";
@@ -4284,11 +591,11 @@ function generateMinimalConfig(updates) {
 }
 // src/utils/tsconfigWriter.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 function findTsConfig(cwd) {
-  const tsconfigPath = path14.join(cwd, "tsconfig.json");
-  if (fs14.existsSync(tsconfigPath)) {
+  const tsconfigPath = path4.join(cwd, "tsconfig.json");
+  if (fs4.existsSync(tsconfigPath)) {
     return tsconfigPath;
   }
   return null;
@@ -4299,7 +606,7 @@ function readTsConfig(cwd) {
     return {};
   }
   try {
-    const content = fs14.readFileSync(tsconfigPath, "utf-8");
+    const content = fs4.readFileSync(tsconfigPath, "utf-8");
     const config = JSON.parse(content);
     return {
       jsxImportSource: config.compilerOptions?.jsxImportSource,
@@ -4315,7 +622,7 @@ function updateTsConfig(cwd, updates) {
     return false;
   }
   try {
-    const content = fs14.readFileSync(tsconfigPath, "utf-8");
+    const content = fs4.readFileSync(tsconfigPath, "utf-8");
     const config = JSON.parse(content);
     if (!config.compilerOptions) {
       config.compilerOptions = {};
@@ -4323,7 +630,7 @@ function updateTsConfig(cwd, updates) {
     if (updates.jsxImportSource !== void 0) {
       config.compilerOptions.jsxImportSource = updates.jsxImportSource;
     }
-    fs14.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    fs4.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     return true;
   } catch {
     return false;
@@ -4331,8 +638,8 @@ function updateTsConfig(cwd, updates) {
 }
 // src/utils/dependencyManager.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import { execFileSync } from "child_process";
 var REACT_SPECIFIC_LIBRARIES = [
   "@tanstack/react-query",
@@ -4373,22 +680,22 @@ var REACT_SPECIFIC_LIBRARIES = [
   "@use-gesture/react"
 ];
 function detectPackageManager(cwd) {
-  if (fs15.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs5.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs15.existsSync(path15.join(cwd, "yarn.lock"))) {
+  if (fs5.existsSync(path5.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (fs15.existsSync(path15.join(cwd, "bun.lockb"))) {
+  if (fs5.existsSync(path5.join(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (fs15.existsSync(path15.join(cwd, "package-lock.json"))) {
+  if (fs5.existsSync(path5.join(cwd, "package-lock.json"))) {
     return "npm";
   }
-  const packageJsonPath = path15.join(cwd, "package.json");
-  if (fs15.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(cwd, "package.json");
+  if (fs5.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
       const pm = packageJson.packageManager;
       if (pm) {
         if (pm.startsWith("pnpm")) return "pnpm";
@@ -4402,15 +709,15 @@ function detectPackageManager(cwd) {
   return "npm";
 }
 function getInstalledDependencies(cwd) {
-  const packageJsonPath = path15.join(cwd, "package.json");
-  if (!fs15.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(cwd, "package.json");
+  if (!fs5.existsSync(packageJsonPath)) {
     return {
       dependencies: {},
       devDependencies: {}
     };
   }
   try {
-    const content = fs15.readFileSync(packageJsonPath, "utf-8");
+    const content = fs5.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     return {
       dependencies: packageJson.dependencies || {},
@@ -4751,7 +1058,7 @@ async function askConfirmation(question, defaultValue) {
 // src/index.ts
 program.name("cloudwerk").description("Cloudwerk CLI - Build and deploy full-stack apps to Cloudflare").version(VERSION);
 program.command("dev [path]").description("Start development server").option("-p, --port <number>", "Port to listen on", String(DEFAULT_PORT)).option("-H, --host <host>", "Host to bind", DEFAULT_HOST).option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(dev);
-program.command("build [path]").description("Build project for production").option("-o, --output <dir>", "Output directory", "./dist").option("--ssg", "Generate static pages for routes with rendering: static").option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(build9);
+program.command("build [path]").description("Build project for production deployment to Cloudflare Workers").option("-o, --output <dir>", "Output directory", "./dist").option("--ssg", "Generate static pages for routes with rendering: static").option("--minify", "Minify bundles (default: true)").option("--no-minify", "Disable minification").option("--sourcemap", "Generate source maps").option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(build);
 var configCmd = program.command("config").description("Manage Cloudwerk configuration");
 configCmd.command("get <key>").description("Get a configuration value").action(configGet);
 configCmd.command("set <key> <value>").description("Set a configuration value").action(configSet);