hono 4.13.13 → 5.0.0-rc.1

package/dist/helper/ssg/ssg.js

@@ -70,11 +70,6 @@ const combineAfterGenerateHooks = (hooks, fsModule, options) => {
 		for (const hook of hooks) await hook(result, fsModule, options);
 	};
 };
-/**
-* @experimental
-* `fetchRoutesContent` is an experimental feature.
-* The API might be changed.
-*/
 const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
 	const baseURL = "http://localhost";
 	const pool = createPool({ concurrency });
@@ -136,11 +131,6 @@ const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook,
 		});
 	}
 };
-/**
-* @experimental
-* `saveContentToFile` is an experimental feature.
-* The API might be changed.
-*/
 const createdDirs = /* @__PURE__ */ new Set();
 const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
 	const awaitedData = await data;
@@ -156,11 +146,6 @@ const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
 	else if (content instanceof ArrayBuffer) await fsModule.writeFile(filePath, new Uint8Array(content));
 	return filePath;
 };
-/**
-* @experimental
-* `toSSG` is an experimental feature.
-* The API might be changed.
-*/
 const toSSG = async (app, fs, options) => {
 	let result;
 	const getInfoPromises = [];
@@ -169,9 +154,6 @@ const toSSG = async (app, fs, options) => {
 	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]);

package/dist/helper/ssg/utils.js

@@ -1,11 +1,6 @@
 import "../../router.js";
 import { findTargetHandler, isMiddleware } from "../../utils/handler.js";
 //#region src/helper/ssg/utils.ts
-/**
-* Get dirname
-* @param path File Path
-* @returns Parent dir path
-*/
 const dirname = (path) => {
 	return path.split(/[\/\\]/).slice(0, -1).join("/");
 };

package/dist/helper/testing/index.js

@@ -1,9 +1,5 @@
 import { hc } from "../../client/client.js";
 //#region src/helper/testing/index.ts
-/**
-* @module
-* Testing Helper for Hono.
-*/
 const testClient = (app, Env, executionCtx, options) => {
 	const customFetch = (input, init) => {
 		return app.request(input, init, Env, executionCtx);

package/dist/helper/websocket/index.js

@@ -1,7 +1,4 @@
 //#region src/helper/websocket/index.ts
-/**
-* A context for controlling WebSockets
-*/
 var WSContext = class {
 	#init;
 	constructor(init) {
@@ -27,9 +24,6 @@ var WSContext = class {
 const createWSMessageEvent = (source) => {
 	return new MessageEvent("message", { data: source });
 };
-/**
-* Create a WebSocket adapter/helper
-*/
 const defineWebSocketHelper = (handler) => {
 	return ((...args) => {
 		if (typeof args[0] === "function") {

package/dist/{types/hono-base.d.ts → hono-base.d.ts}

@@ -1,6 +1,6 @@
 import { Router } from "./router.js";
-import { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from "./types.js";
-import { Context, ExecutionContext } from "./context.js";
+import { Env, FallbackHandlerInterface, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, OnHandlerInterface, RouterRoute, Schema } from "./types.js";
+import { ExecutionContext } from "./context.js";
 //#region src/hono-base.d.ts
 type GetPath<E extends Env> = (request: Request, options?: {
   env?: E['Bindings'];
@@ -47,12 +47,6 @@ export type HonoOptions<E extends Env> = {
    */
   getPath?: GetPath<E>;
 };
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-  optionHandler?: MountOptionHandler;
-  replaceRequest?: MountReplaceRequest | false;
-};
 declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
   
   get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
@@ -65,12 +59,56 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
   all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
   on: OnHandlerInterface<E, S, BasePath>;
   use: MiddlewareHandlerInterface<E, S, BasePath>;
+  /**
+   * `.onError()` adds middleware that runs when an error is caught.
+   * Paths are relative to the current base path and default to `*`, for any HTTP method.
+   * The error is available as `c.error`. Matching middleware runs in registration order,
+   * with nested applications taking priority. If every middleware calls `next()`,
+   * the built-in error handler returns the response.
+   * Errors thrown by this middleware are handled by the built-in error handler.
+   * Non-Error values thrown by handlers are wrapped in an Error with the original value as its cause.
+   * If the thrown value is a string, it is also used as the error message.
+   * Request parameters come from the original route, not this scope, and may be absent.
+   *
+   * @param {string} [path] - path to scope the error middleware
+   * @param {...MiddlewareHandler[]} handlers - middleware to run when handling an error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError('/api/*', async (c, next) => {
+   *   console.error(c.error)
+   *   await next()
+   * })
+   * ```
+   */
+  onError: FallbackHandlerInterface<E, S, BasePath, CurrentPath>;
+  /**
+   * `.notFound()` adds middleware that runs when a not-found response is requested.
+   * It uses the same path scoping and ordering as `.onError()`, including for `c.notFound()`.
+   * If every matching middleware calls `next()`, the built-in not-found handler returns the response.
+   * Request parameters come from the original route, not this scope, and may be absent.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {string} [path] - path to scope the not-found middleware
+   * @param {...MiddlewareHandler[]} handlers - middleware to run when handling not found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound('/api/*', async (c, next) => {
+   *   c.header('x-not-found', 'true')
+   *   await next()
+   * })
+   * ```
+   */
+  notFound: FallbackHandlerInterface<E, S, BasePath, CurrentPath>;
   router: Router<[H, RouterRoute]>;
   readonly getPath: GetPath<E>;
   private _basePath;
   routes: RouterRoute[];
   constructor(options?: HonoOptions<E>);
-  private errorHandler;
   /**
    * `.route()` allows grouping other Hono instance in routes.
    *
@@ -104,74 +142,6 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
    * ```
    */
   basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-  /**
-   * `.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: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-  /**
-   * `.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: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-  /**
-   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-   *
-   * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
-   *
-   * @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(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
   /**
    * `.fetch()` will be entry point of your app.
    *
@@ -197,24 +167,6 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
    * @see https://hono.dev/docs/api/hono#request
    */
   request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-  /**
-   * `.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: () => void;
 }
 //#endregion
 export { Hono as HonoBase };

package/dist/hono-base.js

@@ -1,13 +1,11 @@
-import { compose } from "./compose.js";
+import { compose, toError } from "./compose.js";
+import { GET_RESPONSE } from "./context/constants.js";
 import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
 import { Context } from "./context.js";
 import { METHODS } from "./router.js";
-import { COMPOSED_HANDLER } from "./utils/constants.js";
 //#region src/hono-base.ts
-/**
-* @module
-* This module is the base module for the Hono object.
-*/
+const METHOD_NAME_NOT_FOUND = "@NOT_FOUND";
+const METHOD_NAME_ERROR = "@ERROR";
 const notFoundHandler = (c) => {
 	return c.text("404 Not Found", 404);
 };
@@ -19,6 +17,15 @@ const errorHandler = (err, c) => {
 	console.error(err);
 	return c.text("Internal Server Error", 500);
 };
+const errorFallback = (c) => errorHandler(c.error, c);
+const rethrow = (err) => {
+	throw err;
+};
+const byDepthDesc = (a, b) => b[0][1].depth - a[0][1].depth;
+const getResponse = (context) => {
+	if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+	return context.res;
+};
 var Hono = class Hono {
 	get;
 	post;
@@ -30,6 +37,8 @@ var Hono = class Hono {
 	all;
 	on;
 	use;
+	onError;
+	notFound;
 	router;
 	getPath;
 	_basePath = "/";
@@ -63,11 +72,11 @@ var Hono = class Hono {
 				this.#path = "*";
 				handlers.unshift(arg1);
 			}
-			handlers.forEach((handler) => {
-				this.#addRoute("ALL", this.#path, handler);
-			});
+			handlers.forEach((handler) => this.#addRoute("ALL", this.#path, handler));
 			return this;
 		};
+		this.onError = (...handlers) => this.#addRoutes(METHOD_NAME_ERROR, handlers);
+		this.notFound = (...handlers) => this.#addRoutes(METHOD_NAME_NOT_FOUND, handlers);
 		const { strict, ...optionsWithoutStrict } = options;
 		Object.assign(this, optionsWithoutStrict);
 		this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
@@ -77,187 +86,67 @@ var Hono = class Hono {
 			router: this.router,
 			getPath: this.getPath
 		});
-		clone.errorHandler = this.errorHandler;
-		clone.#notFoundHandler = this.#notFoundHandler;
 		clone.routes = this.routes;
 		return clone;
 	}
-	#notFoundHandler = notFoundHandler;
-	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(path, app) {
 		const subApp = this.basePath(path);
-		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, r.basePath);
-		});
+		app.routes.forEach((r) => subApp.#addRoute(r.method, r.path, r.handler, r));
 		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(path) {
 		const subApp = this.#clone();
 		subApp._basePath = mergePath(this._basePath, path);
 		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.
-	*
-	* @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
-	*
-	* @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(path, 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 options = optionHandler(c);
-			return Array.isArray(options) ? options : [options];
-		} : (c) => {
-			let executionContext = void 0;
-			try {
-				executionContext = c.executionCtx;
-			} catch {}
-			return [c.env, executionContext];
-		};
-		replaceRequest ||= (() => {
-			const mergedPath = mergePath(this._basePath, path);
-			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-			return (request) => {
-				const url = new URL(request.url);
-				url.pathname = this.getPath(request).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("ALL", mergePath(path, "*"), handler);
-		return this;
-	}
-	#addRoute(method, path, handler, baseRoutePath) {
+	#addRoute(method, path, handler, baseRoute) {
 		path = mergePath(this._basePath, path);
 		const r = {
-			basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+			basePath: mergePath(this._basePath, baseRoute?.basePath ?? "/"),
 			path,
 			method,
-			handler
+			handler,
+			depth: (baseRoute?.depth ?? -1) + 1
 		};
 		this.router.add(method, path, [handler, r]);
 		this.routes.push(r);
 	}
-	#handleError(err, c) {
-		if (err instanceof Error) return this.errorHandler(err, c);
-		throw err;
+	#addRoutes(method, handlers) {
+		const path = typeof handlers[0] === "string" ? handlers.shift() : "*";
+		handlers.forEach((handler) => this.#addRoute(method, path, handler));
+		return this;
+	}
+	#dispatchInternal(method, c) {
+		const handlers = this.router.match(method, c.req.path)[0].filter(([[, route]]) => route.method === method);
+		const fallback = method === METHOD_NAME_ERROR ? errorFallback : notFoundHandler;
+		if (!handlers.length) return fallback(c);
+		handlers.sort(byDepthDesc);
+		const res = c[GET_RESPONSE];
+		const finalized = c.finalized;
+		if (res?.status && !res.bodyUsed && !res.body?.locked) {
+			const mutableRes = new Response(res.body, res);
+			c.res = void 0;
+			c.res = mutableRes;
+		}
+		c.finalized = false;
+		const handleError = c.error ? rethrow : (err) => this.#handleError(err, c);
+		return compose(handlers, method === METHOD_NAME_ERROR ? errorHandler : handleError, fallback, false)(c).then(getResponse).catch(handleError).finally(() => {
+			c.res = void 0;
+			if (method !== METHOD_NAME_ERROR) c.res = res;
+			c.finalized = finalized;
+		});
+	}
+	#handleError = (err, c) => {
+		c.error = toError(err);
+		return this.#dispatchInternal(METHOD_NAME_ERROR, c);
+	};
+	#notFound = (c) => this.#dispatchInternal(METHOD_NAME_NOT_FOUND, c);
+	async #dispatchComposed(c, matchResult) {
+		try {
+			return getResponse(await compose(matchResult[0], this.#handleError, this.#notFound)(c));
+		} catch (err) {
+			return this.#handleError(err, c);
+		}
 	}
 	#dispatch(request, executionCtx, env, method) {
 		if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
@@ -268,83 +157,29 @@ var Hono = class Hono {
 			matchResult,
 			env,
 			executionCtx,
-			notFoundHandler: this.#notFoundHandler
+			notFoundHandler: this.#notFound
 		});
 		if (matchResult[0].length === 1) {
 			let res;
 			try {
 				res = matchResult[0][0][0][0](c, async () => {
-					c.res = await this.#notFoundHandler(c);
+					c.res = await this.#notFound(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);
+			return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFound(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFound(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);
-			}
-		})();
+		return this.#dispatchComposed(c, matchResult);
 	}
-	/**
-	* `.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} executionCtx - 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));
-		});
-	};
 };
 //#endregion
 export { Hono as HonoBase };

package/dist/{types/hono.d.ts → hono.d.ts}

@@ -1,5 +1,5 @@
-import { HonoBase as Hono$1, HonoOptions } from "./hono-base.js";
 import { BlankEnv, BlankSchema, Env, Schema } from "./types.js";
+import { HonoBase as Hono$1, HonoOptions } from "./hono-base.js";
 //#region src/hono.d.ts
 /**
  * The Hono class extends the functionality of the HonoBase class.

package/dist/hono.js

@@ -5,20 +5,7 @@ import { SmartRouter } from "./router/smart-router/router.js";
 import { TrieRouter } from "./router/trie-router/router.js";
 import "./router/trie-router/index.js";
 //#region src/hono.ts
-/**
-* The Hono class extends the functionality of the HonoBase class.
-* It sets up routing and allows for custom options to be passed.
-*
-* @template E - The environment type.
-* @template S - The schema type.
-* @template BasePath - The base path type.
-*/
 var Hono = class extends Hono$1 {
-	/**
-	* 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()] });