hono 4.7.10 → 4.8.0

package/dist/cjs/middleware/logger/index.js

@@ -37,8 +37,8 @@ const time = (start) => {
   const delta = Date.now() - start;
   return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
-const colorStatus = (status) => {
-  const colorEnabled = (0, import_color.getColorEnabled)();
+const colorStatus = async (status) => {
+  const colorEnabled = await (0, import_color.getColorEnabledAsync)();
   if (colorEnabled) {
     switch (status / 100 | 0) {
       case 5:
@@ -53,18 +53,18 @@ const colorStatus = (status) => {
   }
   return `${status}`;
 };
-function log(fn, prefix, method, path, status = 0, elapsed) {
-  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`;
   fn(out);
 }
 const logger = (fn = console.log) => {
   return async function logger2(c, next) {
     const { method, url } = c.req;
     const path = url.slice(url.indexOf("/", 8));
-    log(fn, "<--" /* Incoming */, method, path);
+    await log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();
-    log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
+    await log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/request/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  GET_MATCH_RESULT: () => GET_MATCH_RESULT
+});
+module.exports = __toCommonJS(constants_exports);
+const GET_MATCH_RESULT = Symbol();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GET_MATCH_RESULT
+});

package/dist/cjs/request.js

@@ -21,6 +21,7 @@ __export(request_exports, {
   HonoRequest: () => HonoRequest
 });
 module.exports = __toCommonJS(request_exports);
+var import_constants = require("./request/constants");
 var import_body = require("./utils/body");
 var import_url = require("./utils/url");
 const tryDecodeURIComponent = (str) => (0, import_url.tryDecode)(str, import_url.decodeURIComponent_);
@@ -122,6 +123,9 @@ class HonoRequest {
   get method() {
     return this.raw.method;
   }
+  get [import_constants.GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
   get matchedRoutes() {
     return this.#matchResult[0].map(([[, route]]) => route);
   }

package/dist/cjs/router/trie-router/node.js

@@ -50,11 +50,10 @@ class Node {
       const nextP = parts[i + 1];
       const pattern = (0, import_url.getPattern)(p, nextP);
       const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (Object.keys(curNode.#children).includes(key)) {
+      if (key in curNode.#children) {
         curNode = curNode.#children[key];
-        const pattern2 = (0, import_url.getPattern)(p, nextP);
-        if (pattern2) {
-          possibleKeys.push(pattern2[1]);
+        if (pattern) {
+          possibleKeys.push(pattern[1]);
         }
         continue;
       }
@@ -65,14 +64,13 @@ class Node {
       }
       curNode = curNode.#children[key];
     }
-    const m = /* @__PURE__ */ Object.create(null);
-    const handlerSet = {
-      handler,
-      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.#order
-    };
-    m[method] = handlerSet;
-    curNode.#methods.push(m);
+    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) {
@@ -135,7 +133,7 @@ class Node {
             }
             continue;
           }
-          if (part === "") {
+          if (!part) {
             continue;
           }
           const [key, name, matcher] = pattern;

package/dist/cjs/utils/body.js

@@ -68,7 +68,11 @@ const handleParsingAllValues = (form, key, value) => {
       form[key] = [form[key], value];
     }
   } else {
-    form[key] = value;
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
   }
 };
 const handleParsingNestedValues = (form, key, value) => {

package/dist/cjs/utils/color.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,10 +17,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var color_exports = {};
 __export(color_exports, {
-  getColorEnabled: () => getColorEnabled
+  getColorEnabled: () => getColorEnabled,
+  getColorEnabledAsync: () => getColorEnabledAsync
 });
 module.exports = __toCommonJS(color_exports);
 function getColorEnabled() {
@@ -26,7 +33,13 @@ function getColorEnabled() {
   const isNoColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : process !== void 0 ? "NO_COLOR" in process?.env : false;
   return !isNoColor;
 }
+async function getColorEnabledAsync() {
+  const { navigator } = globalThis;
+  const isNoColor = navigator !== void 0 && navigator.userAgent === "Cloudflare-Workers" ? "NO_COLOR" in ((await import("cloudflare:workers")).env ?? {}) : !getColorEnabled();
+  return !isNoColor;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getColorEnabled
+  getColorEnabled,
+  getColorEnabledAsync
 });

package/dist/cjs/utils/jwt/jwt.js

@@ -94,7 +94,6 @@ const verifyFromJwks = async (token, options, init) => {
   if (!header.kid) {
     throw new import_types.JwtHeaderRequiresKid(header);
   }
-  let keys = typeof options.keys === "function" ? await options.keys() : options.keys;
   if (options.jwks_uri) {
     const response = await fetch(options.jwks_uri, init);
     if (!response.ok) {
@@ -107,15 +106,15 @@ const verifyFromJwks = async (token, options, init) => {
     if (!Array.isArray(data.keys)) {
       throw new Error('invalid JWKS response. "keys" field is not an array');
     }
-    if (keys) {
-      keys.push(...data.keys);
+    if (options.keys) {
+      options.keys.push(...data.keys);
     } else {
-      keys = data.keys;
+      options.keys = data.keys;
     }
-  } else if (!keys) {
+  } else if (!options.keys) {
     throw new Error('verifyFromJwks requires options for either "keys" or "jwks_uri" or both');
   }
-  const matchingKey = keys.find((key) => key.kid === header.kid);
+  const matchingKey = options.keys.find((key) => key.kid === header.kid);
   if (!matchingKey) {
     throw new import_types.JwtTokenInvalid(token);
   }

package/dist/cjs/utils/mime.js

@@ -88,6 +88,7 @@ const _baseMimes = {
   wasm: "application/wasm",
   webm: "video/webm",
   weba: "audio/webm",
+  webmanifest: "application/manifest+json",
   webp: "image/webp",
   woff: "font/woff",
   woff2: "font/woff2",

package/dist/cjs/utils/url.js

@@ -100,7 +100,10 @@ const tryDecode = (str, decoder) => {
 const tryDecodeURI = (str) => tryDecode(str, decodeURI);
 const getPath = (request) => {
   const url = request.url;
-  const start = url.indexOf("/", 8);
+  const start = url.indexOf(
+    "/",
+    url.charCodeAt(9) === 58 ? 13 : 8
+  );
   let i = start;
   for (; i < url.length; i++) {
     const charCode = url.charCodeAt(i);
@@ -162,7 +165,7 @@ const _decodeURI = (value) => {
   if (value.indexOf("+") !== -1) {
     value = value.replace(/\+/g, " ");
   }
-  return value.indexOf("%") !== -1 ? decodeURIComponent_(value) : value;
+  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
 };
 const _getQueryParam = (url, key, multiple) => {
   let encoded;

package/dist/context.js

@@ -2,11 +2,11 @@
 import { HonoRequest } from "./request.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "./utils/html.js";
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setHeaders = (headers, map = {}) => {
-  for (const key of Object.keys(map)) {
-    headers.set(key, map[key]);
-  }
-  return headers;
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
 };
 var Context = class {
   #rawRequest;
@@ -15,15 +15,13 @@ var Context = class {
   #var;
   finalized = false;
   error;
-  #status = 200;
+  #status;
   #executionCtx;
-  #headers;
-  #preparedHeaders;
   #res;
-  #isFresh = true;
   #layout;
   #renderer;
   #notFoundHandler;
+  #preparedHeaders;
   #matchResult;
   #path;
   constructor(req, options) {
@@ -55,11 +53,11 @@ var Context = class {
     }
   }
   get res() {
-    this.#isFresh = false;
-    return this.#res ||= new Response("404 Not Found", { status: 404 });
+    return this.#res ||= new Response(null, {
+      headers: this.#preparedHeaders ??= new Headers()
+    });
   }
   set res(_res) {
-    this.#isFresh = false;
     if (this.#res && _res) {
       _res = new Response(_res.body, _res);
       for (const [k, v] of this.#res.headers.entries()) {
@@ -93,42 +91,16 @@ var Context = class {
     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) {
-      if (this.#headers) {
-        this.#headers.delete(name);
-      } else if (this.#preparedHeaders) {
-        delete this.#preparedHeaders[name.toLocaleLowerCase()];
-      }
-      if (this.finalized) {
-        this.res.headers.delete(name);
-      }
-      return;
-    }
-    if (options?.append) {
-      if (!this.#headers) {
-        this.#isFresh = false;
-        this.#headers = new Headers(this.#preparedHeaders);
-        this.#preparedHeaders = {};
-      }
-      this.#headers.append(name, value);
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
     } else {
-      if (this.#headers) {
-        this.#headers.set(name, value);
-      } else {
-        this.#preparedHeaders ??= {};
-        this.#preparedHeaders[name.toLowerCase()] = value;
-      }
-    }
-    if (this.finalized) {
-      if (options?.append) {
-        this.res.headers.append(name, value);
-      } else {
-        this.res.headers.set(name, value);
-      }
+      headers.set(name, value);
     }
   };
   status = (status) => {
-    this.#isFresh = false;
     this.#status = status;
   };
   set = (key, value) => {
@@ -145,94 +117,54 @@ var Context = class {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    if (this.#isFresh && !headers && !arg && this.#status === 200) {
-      return new Response(data, {
-        headers: this.#preparedHeaders
-      });
-    }
-    if (arg && typeof arg !== "number") {
-      const header = new Headers(arg.headers);
-      if (this.#headers) {
-        this.#headers.forEach((v, k) => {
-          if (k === "set-cookie") {
-            header.append(k, v);
-          } else {
-            header.set(k, v);
-          }
-        });
-      }
-      const headers2 = setHeaders(header, this.#preparedHeaders);
-      return new Response(data, {
-        headers: headers2,
-        status: arg.status ?? this.#status
-      });
-    }
-    const status = typeof arg === "number" ? arg : this.#status;
-    this.#preparedHeaders ??= {};
-    this.#headers ??= new Headers();
-    setHeaders(this.#headers, this.#preparedHeaders);
-    if (this.#res) {
-      this.#res.headers.forEach((v, k) => {
-        if (k === "set-cookie") {
-          this.#headers?.append(k, v);
+    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 {
-          this.#headers?.set(k, v);
+          responseHeaders.set(key, value);
         }
-      });
-      setHeaders(this.#headers, this.#preparedHeaders);
+      }
     }
-    headers ??= {};
-    for (const [k, v] of Object.entries(headers)) {
-      if (typeof v === "string") {
-        this.#headers.set(k, v);
-      } else {
-        this.#headers.delete(k);
-        for (const v2 of v) {
-          this.#headers.append(k, v2);
+    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);
+          }
         }
       }
     }
-    return new Response(data, {
-      status,
-      headers: this.#headers
-    });
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return new Response(data, { status, headers: responseHeaders });
   }
   newResponse = (...args) => this.#newResponse(...args);
-  body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
-  };
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
   text = (text, arg, headers) => {
-    if (!this.#preparedHeaders) {
-      if (this.#isFresh && !headers && !arg) {
-        return new Response(text);
-      }
-      this.#preparedHeaders = {};
-    }
-    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    if (typeof arg === "number") {
-      return this.#newResponse(text, arg, headers);
-    }
-    return this.#newResponse(text, arg);
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
+      text,
+      arg,
+      setDefaultContentType(TEXT_PLAIN, headers)
+    );
   };
   json = (object, arg, headers) => {
-    const body = JSON.stringify(object);
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "application/json";
-    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
+    return this.#newResponse(
+      JSON.stringify(object),
+      arg,
+      setDefaultContentType("application/json", headers)
+    );
   };
   html = (html, arg, headers) => {
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
-    if (typeof html === "object") {
-      return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
-      });
-    }
-    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
+    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 = (location, status) => {
-    this.#headers ??= new Headers();
-    this.#headers.set("Location", String(location));
+    this.header("Location", String(location));
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {

package/dist/helper/route/index.js

@@ -0,0 +1,43 @@
+// src/helper/route/index.ts
+import { GET_MATCH_RESULT } from "../../request/constants.js";
+import { getPattern, splitRoutingPath } from "../../utils/url.js";
+var matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
+var routePath = (c) => matchedRoutes(c)[c.req.routeIndex].path;
+var baseRoutePath = (c) => matchedRoutes(c)[c.req.routeIndex].basePath;
+var basePathCacheMap = /* @__PURE__ */ new WeakMap();
+var basePath = (c) => {
+  const routeIndex = c.req.routeIndex;
+  const cache = basePathCacheMap.get(c) || [];
+  if (typeof cache[routeIndex] === "string") {
+    return cache[routeIndex];
+  }
+  let result;
+  const rp = baseRoutePath(c);
+  if (!/[:*]/.test(rp)) {
+    result = rp;
+  } else {
+    const paths = splitRoutingPath(rp);
+    const reqPath = c.req.path;
+    let basePathLength = 0;
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const pattern = getPattern(paths[i], paths[i + 1]);
+      if (pattern) {
+        const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+        basePathLength += reqPath.substring(basePathLength + 1).match(re)?.[0].length || 0;
+      } else {
+        basePathLength += paths[i].length;
+      }
+      basePathLength += 1;
+    }
+    result = reqPath.substring(0, basePathLength);
+  }
+  cache[routeIndex] = result;
+  basePathCacheMap.set(c, cache);
+  return result;
+};
+export {
+  basePath,
+  baseRoutePath,
+  matchedRoutes,
+  routePath
+};

package/dist/helper/ssg/ssg.js

@@ -6,6 +6,7 @@ import { SSG_CONTEXT, X_HONO_DISABLE_SSG_HEADER_KEY } from "./middleware.js";
 import { dirname, filterStaticGenerateRoutes, joinPaths } from "./utils.js";
 var DEFAULT_CONCURRENCY = 2;
 var DEFAULT_CONTENT_TYPE = "text/plain";
+var DEFAULT_OUTPUT_DIR = "./static";
 var generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
   const extension = determineExtension(mimeType, extensionMap);
   if (routePath.endsWith(`.${extension}`)) {
@@ -82,13 +83,13 @@ var combineAfterResponseHooks = (hooks) => {
     return currentRes;
   };
 };
-var combineAfterGenerateHooks = (hooks) => {
+var combineAfterGenerateHooks = (hooks, fsModule, options) => {
   if (!Array.isArray(hooks)) {
     return hooks;
   }
   return async (result) => {
     for (const hook of hooks) {
-      await hook(result);
+      await hook(result, fsModule, options);
     }
   };
 };
@@ -190,14 +191,50 @@ var toSSG = async (app, fs, options) => {
   let result;
   const getInfoPromises = [];
   const savePromises = [];
+  const plugins = options?.plugins || [];
+  const beforeRequestHooks = [];
+  const afterResponseHooks = [];
+  const afterGenerateHooks = [];
+  if (options?.beforeRequestHook) {
+    beforeRequestHooks.push(
+      ...Array.isArray(options.beforeRequestHook) ? options.beforeRequestHook : [options.beforeRequestHook]
+    );
+  }
+  if (options?.afterResponseHook) {
+    afterResponseHooks.push(
+      ...Array.isArray(options.afterResponseHook) ? options.afterResponseHook : [options.afterResponseHook]
+    );
+  }
+  if (options?.afterGenerateHook) {
+    afterGenerateHooks.push(
+      ...Array.isArray(options.afterGenerateHook) ? options.afterGenerateHook : [options.afterGenerateHook]
+    );
+  }
+  for (const plugin of plugins) {
+    if (plugin.beforeRequestHook) {
+      beforeRequestHooks.push(
+        ...Array.isArray(plugin.beforeRequestHook) ? plugin.beforeRequestHook : [plugin.beforeRequestHook]
+      );
+    }
+    if (plugin.afterResponseHook) {
+      afterResponseHooks.push(
+        ...Array.isArray(plugin.afterResponseHook) ? plugin.afterResponseHook : [plugin.afterResponseHook]
+      );
+    }
+    if (plugin.afterGenerateHook) {
+      afterGenerateHooks.push(
+        ...Array.isArray(plugin.afterGenerateHook) ? plugin.afterGenerateHook : [plugin.afterGenerateHook]
+      );
+    }
+  }
   try {
-    const outputDir = options?.dir ?? "./static";
+    const outputDir = options?.dir ?? DEFAULT_OUTPUT_DIR;
     const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
     const combinedBeforeRequestHook = combineBeforeRequestHooks(
-      options?.beforeRequestHook || ((req) => req)
+      beforeRequestHooks.length > 0 ? beforeRequestHooks : [(req) => req]
     );
     const combinedAfterResponseHook = combineAfterResponseHooks(
-      options?.afterResponseHook || ((req) => req)
+      afterResponseHooks.length > 0 ? afterResponseHooks : [(req) => req]
     );
     const getInfoGen = fetchRoutesContent(
       app,
@@ -234,13 +271,14 @@ var toSSG = async (app, fs, options) => {
     const errorObj = error instanceof Error ? error : new Error(String(error));
     result = { success: false, files: [], error: errorObj };
   }
-  if (options?.afterGenerateHook) {
-    const combinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
-    await combinedAfterGenerateHooks(result);
+  if (afterGenerateHooks.length > 0) {
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(afterGenerateHooks, fs, options);
+    await combinedAfterGenerateHooks(result, fs, options);
   }
   return result;
 };
 export {
+  DEFAULT_OUTPUT_DIR,
   combineAfterGenerateHooks,
   combineAfterResponseHooks,
   combineBeforeRequestHooks,

package/dist/helper/testing/index.js

@@ -1,10 +1,10 @@
 // src/helper/testing/index.ts
 import { hc } from "../../client/index.js";
-var testClient = (app, Env, executionCtx) => {
+var testClient = (app, Env, executionCtx, options) => {
   const customFetch = (input, init) => {
     return app.request(input, init, Env, executionCtx);
   };
-  return hc("http://localhost", { fetch: customFetch });
+  return hc("http://localhost", { ...options, fetch: customFetch });
 };
 export {
   testClient

package/dist/hono-base.js

@@ -9,7 +9,8 @@ var notFoundHandler = (c) => {
 };
 var errorHandler = (err, c) => {
   if ("getResponse" in err) {
-    return err.getResponse();
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
   }
   console.error(err);
   return c.text("Internal Server Error", 500);
@@ -158,7 +159,7 @@ var Hono = class {
   #addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = mergePath(this._basePath, path);
-    const r = { path, method, handler };
+    const r = { basePath: this._basePath, path, method, handler };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }

package/dist/jsx/components.js

@@ -2,7 +2,9 @@
 import { raw } from "../helper/html/index.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { DOM_RENDERER } from "./constants.js";
+import { useContext } from "./context.js";
 import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
+import { StreamingContext } from "./streaming.js";
 var errorBoundaryCounter = 0;
 var childrenToString = async (children) => {
   try {
@@ -23,6 +25,7 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
   if (!Array.isArray(children)) {
     children = [children];
   }
+  const nonce = useContext(StreamingContext)?.scriptNonce;
   let fallbackStr;
   const fallbackRes = (error) => {
     onError?.(error);
@@ -79,7 +82,7 @@ d.replaceWith(c.content)
           }
           htmlArray = htmlArray.flat();
           const content = htmlArray.join("");
-          let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script>
+          let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
 ((d,c) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')