routup 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/{src-CNoRH9eg.mjs → src-Ck8GklBr.mjs}

@@ -1,57 +1,137 @@
+import { FastURL } from "srvx";
 import { HTTPError, isHTTPError } from "@ebec/http";
 import { Buffer } from "node:buffer";
 import { subtle } from "uncrypto";
-import { distinctArray, hasOwnProperty, merge } from "smob";
+import { merge } from "smob";
 import { compile } from "proxy-addr";
 import { get, getType } from "mime-explorer";
-import { FastURL } from "srvx";
-import { pathToRegexp } from "path-to-regexp";
 import Negotiator from "negotiator";
+import { pathToRegexp } from "path-to-regexp";
 //#region src/constants.ts
-let MethodName = /* @__PURE__ */ function(MethodName) {
-	MethodName["GET"] = "GET";
-	MethodName["POST"] = "POST";
-	MethodName["PUT"] = "PUT";
-	MethodName["PATCH"] = "PATCH";
-	MethodName["DELETE"] = "DELETE";
-	MethodName["OPTIONS"] = "OPTIONS";
-	MethodName["HEAD"] = "HEAD";
-	return MethodName;
-}({});
-let HeaderName = /* @__PURE__ */ function(HeaderName) {
-	HeaderName["ACCEPT"] = "accept";
-	HeaderName["ACCEPT_CHARSET"] = "accept-charset";
-	HeaderName["ACCEPT_ENCODING"] = "accept-encoding";
-	HeaderName["ACCEPT_LANGUAGE"] = "accept-language";
-	HeaderName["ACCEPT_RANGES"] = "accept-ranges";
-	HeaderName["ALLOW"] = "allow";
-	HeaderName["CACHE_CONTROL"] = "cache-control";
-	HeaderName["CONTENT_DISPOSITION"] = "content-disposition";
-	HeaderName["CONTENT_ENCODING"] = "content-encoding";
-	HeaderName["CONTENT_LENGTH"] = "content-length";
-	HeaderName["CONTENT_RANGE"] = "content-range";
-	HeaderName["CONTENT_TYPE"] = "content-type";
-	HeaderName["CONNECTION"] = "connection";
-	HeaderName["COOKIE"] = "cookie";
-	HeaderName["ETag"] = "etag";
-	HeaderName["HOST"] = "host";
-	HeaderName["IF_MODIFIED_SINCE"] = "if-modified-since";
-	HeaderName["IF_NONE_MATCH"] = "if-none-match";
-	HeaderName["LAST_MODIFIED"] = "last-modified";
-	HeaderName["LOCATION"] = "location";
-	HeaderName["RANGE"] = "range";
-	HeaderName["RATE_LIMIT_LIMIT"] = "ratelimit-limit";
-	HeaderName["RATE_LIMIT_REMAINING"] = "ratelimit-remaining";
-	HeaderName["RATE_LIMIT_RESET"] = "ratelimit-reset";
-	HeaderName["RETRY_AFTER"] = "retry-after";
-	HeaderName["SET_COOKIE"] = "set-cookie";
-	HeaderName["TRANSFER_ENCODING"] = "transfer-encoding";
-	HeaderName["X_ACCEL_BUFFERING"] = "x-accel-buffering";
-	HeaderName["X_FORWARDED_HOST"] = "x-forwarded-host";
-	HeaderName["X_FORWARDED_FOR"] = "x-forwarded-for";
-	HeaderName["X_FORWARDED_PROTO"] = "x-forwarded-proto";
-	return HeaderName;
-}({});
+const MethodName = {
+	GET: "GET",
+	POST: "POST",
+	PUT: "PUT",
+	PATCH: "PATCH",
+	DELETE: "DELETE",
+	OPTIONS: "OPTIONS",
+	HEAD: "HEAD"
+};
+const HeaderName = {
+	ACCEPT: "accept",
+	ACCEPT_CHARSET: "accept-charset",
+	ACCEPT_ENCODING: "accept-encoding",
+	ACCEPT_LANGUAGE: "accept-language",
+	ACCEPT_RANGES: "accept-ranges",
+	ALLOW: "allow",
+	CACHE_CONTROL: "cache-control",
+	CONTENT_DISPOSITION: "content-disposition",
+	CONTENT_ENCODING: "content-encoding",
+	CONTENT_LENGTH: "content-length",
+	CONTENT_RANGE: "content-range",
+	CONTENT_TYPE: "content-type",
+	CONNECTION: "connection",
+	COOKIE: "cookie",
+	ETag: "etag",
+	HOST: "host",
+	IF_MODIFIED_SINCE: "if-modified-since",
+	IF_NONE_MATCH: "if-none-match",
+	LAST_MODIFIED: "last-modified",
+	LOCATION: "location",
+	RANGE: "range",
+	RATE_LIMIT_LIMIT: "ratelimit-limit",
+	RATE_LIMIT_REMAINING: "ratelimit-remaining",
+	RATE_LIMIT_RESET: "ratelimit-reset",
+	RETRY_AFTER: "retry-after",
+	SET_COOKIE: "set-cookie",
+	TRANSFER_ENCODING: "transfer-encoding",
+	X_ACCEL_BUFFERING: "x-accel-buffering",
+	X_FORWARDED_HOST: "x-forwarded-host",
+	X_FORWARDED_FOR: "x-forwarded-for",
+	X_FORWARDED_PROTO: "x-forwarded-proto"
+};
+//#endregion
+//#region src/response/helpers/cache.ts
+function setResponseCacheHeaders(event, options) {
+	options = options || {};
+	const cacheControls = ["public"].concat(options.cacheControls || []);
+	if (options.maxAge !== void 0) cacheControls.push(`max-age=${+options.maxAge}`, `s-maxage=${+options.maxAge}`);
+	if (options.modifiedTime) {
+		const modifiedTime = typeof options.modifiedTime === "string" ? new Date(options.modifiedTime) : options.modifiedTime;
+		event.response.headers.set("last-modified", modifiedTime.toUTCString());
+	}
+	event.response.headers.set("cache-control", cacheControls.join(", "));
+}
+//#endregion
+//#region src/error/module.ts
+const ErrorSymbol = Symbol.for("RoutupError");
+var RoutupError = class extends HTTPError {
+	"@instanceof" = ErrorSymbol;
+	constructor(input = {}) {
+		super(input);
+		this.name = "RoutupError";
+	}
+};
+//#endregion
+//#region src/response/helpers/event-stream/utils.ts
+function stripNewlines(value) {
+	return value.replace(/[\r\n]/g, "");
+}
+function serializeEventStreamMessage(message) {
+	let result = "";
+	if (message.id) result += `id: ${stripNewlines(message.id)}\n`;
+	if (message.event) result += `event: ${stripNewlines(message.event)}\n`;
+	if (typeof message.retry === "number" && Number.isInteger(message.retry)) result += `retry: ${message.retry}\n`;
+	const lines = message.data.replace(/\r/g, "").split("\n");
+	for (const line of lines) result += `data: ${line}\n`;
+	result += "\n";
+	return result;
+}
+//#endregion
+//#region src/response/helpers/event-stream/module.ts
+function createEventStream(event, options) {
+	if (options?.maxMessageSize !== void 0) {
+		if (!Number.isInteger(options.maxMessageSize) || options.maxMessageSize < 0) throw new RoutupError("maxMessageSize must be a non-negative integer.");
+	}
+	let controller;
+	let closed = false;
+	const encoder = new TextEncoder();
+	const stream = new ReadableStream({
+		start(ctrl) {
+			controller = ctrl;
+		},
+		cancel() {
+			closed = true;
+		}
+	});
+	const headers = new Headers(event.response.headers);
+	headers.set(HeaderName.CONTENT_TYPE, "text/event-stream");
+	headers.set(HeaderName.CACHE_CONTROL, "private, no-cache, no-store, no-transform, must-revalidate, max-age=0");
+	headers.set(HeaderName.X_ACCEL_BUFFERING, "no");
+	headers.set(HeaderName.CONNECTION, "keep-alive");
+	const handle = {
+		write(message) {
+			if (closed) return false;
+			if (typeof message === "string") return handle.write({ data: message });
+			const serialized = serializeEventStreamMessage(message);
+			if (options?.maxMessageSize !== void 0) {
+				if (encoder.encode(serialized).byteLength > options.maxMessageSize) return false;
+			}
+			controller.enqueue(encoder.encode(serialized));
+			return true;
+		},
+		end() {
+			if (closed) return;
+			closed = true;
+			controller.close();
+		},
+		response: new Response(stream, {
+			status: event.response.status,
+			headers
+		})
+	};
+	return handle;
+}
 //#endregion
 //#region src/utils/header.ts
 function sanitizeHeaderValue(value) {
@@ -193,20 +273,77 @@ function cleanDoubleSlashes(input = "") {
 	return input.replace(/\/+/g, "/");
 }
 //#endregion
+//#region src/response/helpers/header.ts
+function appendResponseHeader(event, name, value) {
+	const { headers } = event.response;
+	if (Array.isArray(value)) for (const v of value) headers.append(name, sanitizeHeaderValue(v));
+	else headers.append(name, sanitizeHeaderValue(value));
+}
+function appendResponseHeaderDirective(event, name, value) {
+	const { headers } = event.response;
+	const existing = headers.get(name);
+	if (!existing) {
+		if (Array.isArray(value)) headers.set(name, sanitizeHeaderValue(value.join("; ")));
+		else headers.set(name, sanitizeHeaderValue(value));
+		return;
+	}
+	const directives = existing.split("; ");
+	if (Array.isArray(value)) directives.push(...value);
+	else directives.push(value);
+	const unique = [...new Set(directives)];
+	headers.set(name, sanitizeHeaderValue(unique.join("; ")));
+}
+//#endregion
+//#region src/response/helpers/utils.ts
+function setResponseContentTypeByFileName(event, fileName) {
+	const ext = extname(fileName);
+	if (ext) {
+		let type = getMimeType(ext.substring(1));
+		if (type) {
+			const charset = getCharsetForMimeType(type);
+			if (charset) type += `; charset=${charset}`;
+			event.response.headers.set(HeaderName.CONTENT_TYPE, type);
+		}
+	}
+}
+//#endregion
+//#region src/response/helpers/header-attachment.ts
+function sanitizeFilename(filename) {
+	return filename.replace(/[\r\n]/g, "");
+}
+function toAsciiFilename(filename) {
+	return filename.replace(/[^\x20-\x7E]/g, "").replace(/"/g, "\\\"");
+}
+function encodeRfc5987(filename) {
+	return encodeURIComponent(filename).replace(/['()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/\*/g, "%2A");
+}
+function setResponseHeaderAttachment(event, filename) {
+	if (typeof filename === "string") setResponseContentTypeByFileName(event, filename);
+	let disposition = "attachment";
+	if (filename) {
+		const sanitized = sanitizeFilename(filename);
+		const ascii = toAsciiFilename(sanitized);
+		disposition += `; filename="${ascii}"`;
+		disposition += `; filename*=UTF-8''${encodeRfc5987(sanitized)}`;
+	}
+	event.response.headers.set(HeaderName.CONTENT_DISPOSITION, disposition);
+}
+//#endregion
+//#region src/response/helpers/header-content-type.ts
+function setResponseHeaderContentType(event, input, ifNotExists) {
+	if (ifNotExists) {
+		if (event.response.headers.get(HeaderName.CONTENT_TYPE)) return;
+	}
+	const contentType = getMimeType(input);
+	if (contentType) event.response.headers.set(HeaderName.CONTENT_TYPE, contentType);
+}
+//#endregion
 //#region src/error/is.ts
 function isError(input) {
 	if (!isHTTPError(input)) return false;
-	return input.name === "RoutupError";
+	return isInstance(input, ErrorSymbol);
 }
 //#endregion
-//#region src/error/module.ts
-var RoutupError = class extends HTTPError {
-	constructor(input = {}) {
-		super(input);
-		this.name = "RoutupError";
-	}
-};
-//#endregion
 //#region src/error/create.ts
 function isNativeError(input) {
 	return isObject(input) && typeof input.message === "string" && typeof input.name === "string";
@@ -216,7 +353,7 @@ function isNativeError(input) {
 * - an existing RoutupError (returned as-is)
 * - an HTTPError (wrapped into a RoutupError preserving status)
 * - an Error (wrapped preserving message and cause)
-* - an options object (statusCode, statusMessage, etc.)
+* - an options object (status, message, etc.)
 * - a message string
 *
 * @param input
@@ -227,8 +364,7 @@ function createError(input) {
 	if (isHTTPError(input)) return new RoutupError({
 		message: input.message,
 		code: input.code,
-		statusCode: input.statusCode,
-		statusMessage: input.statusMessage,
+		status: input.status,
 		redirectURL: input.redirectURL,
 		cause: input
 	});
@@ -242,440 +378,72 @@ function createError(input) {
 	return new RoutupError(options);
 }
 //#endregion
-//#region src/event/module.ts
-var RoutupEvent = class {
-	request;
-	params;
-	path;
-	method;
-	mountPath;
-	error;
-	routerPath;
-	/**
-	* Collected allowed methods (for OPTIONS).
-	*/
-	methodsAllowed;
-	store;
-	_dispatched;
-	_response;
-	/**
-	* Cached parsed URL (avoids double-parsing).
-	*/
-	_url;
-	_searchParams;
-	/**
-	* Continuation function for middleware onion model.
-	*/
-	_next;
-	/**
-	* Whether _next has already been called (guard against double-invocation).
-	*/
-	_nextCalled;
-	/**
-	* The cached result of the next handler.
-	*/
-	_nextResult;
-	constructor(request) {
-		this.request = request;
-		this._url = new FastURL(request.url);
-		this.method = request.method;
-		this.path = this._url.pathname;
-		this.mountPath = "/";
-		this.params = {};
-		this.routerPath = [];
-		this.methodsAllowed = [];
-		this.store = Object.create(null);
-		this._dispatched = false;
-		this._nextCalled = false;
-	}
-	get headers() {
-		return this.request.headers;
+//#region src/response/to-response.ts
+function stripWeakPrefix(etag) {
+	return etag.startsWith("W/") ? etag.slice(2) : etag;
+}
+async function applyEtag(body, event, headers) {
+	const etagFn = event.routerOptions.etag;
+	if (!etagFn) return void 0;
+	const etag = await etagFn(body);
+	if (!etag) return void 0;
+	headers.set("etag", etag);
+	const ifNoneMatch = event.headers.get("if-none-match");
+	if (ifNoneMatch && (ifNoneMatch === "*" || ifNoneMatch.split(",").some((t) => stripWeakPrefix(t.trim()) === stripWeakPrefix(etag)))) return new Response(null, {
+		status: 304,
+		headers
+	});
+}
+async function toResponse(value, event) {
+	if (value === void 0) return;
+	if (value === null) return new Response(null, {
+		status: event.response.status,
+		headers: event.response.headers
+	});
+	if (value instanceof Response) return value;
+	const { status, headers } = event.response;
+	if (typeof value === "string") {
+		if (!headers.has("content-type")) headers.set("content-type", "text/plain; charset=utf-8");
+		const cached = await applyEtag(value, event, headers);
+		if (cached) return cached;
+		return new Response(value, {
+			status,
+			headers
+		});
 	}
-	get searchParams() {
-		if (!this._searchParams) this._searchParams = new URLSearchParams(this._url.search);
-		return this._searchParams;
+	if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
+		if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+		return new Response(value, {
+			status,
+			headers
+		});
 	}
-	get response() {
-		if (!this._response) this._response = {
-			status: 200,
-			headers: new Headers()
-		};
-		return this._response;
+	if (value instanceof ReadableStream) return new Response(value, {
+		status,
+		headers
+	});
+	if (value instanceof Blob) {
+		if (!headers.has("content-type")) headers.set("content-type", value.type || "application/octet-stream");
+		return new Response(value, {
+			status,
+			headers
+		});
 	}
-	get dispatched() {
-		return this._dispatched;
+	if (!headers.has("content-type")) headers.set("content-type", "application/json; charset=utf-8");
+	let json;
+	try {
+		json = JSON.stringify(value);
+	} catch (e) {
+		throw createError({
+			message: "JSON serialization failed",
+			status: 500,
+			cause: e
+		});
 	}
-	set dispatched(value) {
-		this._dispatched = value;
-	}
-	async next() {
-		if (this._nextCalled) return this._nextResult;
-		this._nextCalled = true;
-		if (this._next) this._nextResult = this._next();
-		return this._nextResult;
-	}
-};
-//#endregion
-//#region src/handler/constants.ts
-let HandlerType = /* @__PURE__ */ function(HandlerType) {
-	HandlerType["CORE"] = "core";
-	HandlerType["ERROR"] = "error";
-	return HandlerType;
-}({});
-const HandlerSymbol = /* @__PURE__ */ Symbol.for("Handler");
-//#endregion
-//#region src/hook/constants.ts
-let HookName = /* @__PURE__ */ function(HookName) {
-	HookName["REQUEST"] = "request";
-	HookName["RESPONSE"] = "response";
-	HookName["ERROR"] = "error";
-	HookName["CHILD_MATCH"] = "childMatch";
-	HookName["CHILD_DISPATCH_BEFORE"] = "childDispatchBefore";
-	HookName["CHILD_DISPATCH_AFTER"] = "childDispatchAfter";
-	return HookName;
-}({});
-//#endregion
-//#region src/hook/module.ts
-var HookManager = class {
-	items;
-	constructor() {
-		this.items = {};
-	}
-	addListener(name, fn) {
-		this.items[name] = this.items[name] || [];
-		this.items[name].push(fn);
-		return () => {
-			this.removeListener(name, fn);
-		};
-	}
-	removeListener(name, fn) {
-		if (!this.items[name]) return;
-		if (typeof fn === "undefined") {
-			delete this.items[name];
-			return;
-		}
-		if (typeof fn === "function") {
-			const index = this.items[name].indexOf(fn);
-			if (index !== -1) this.items[name].splice(index, 1);
-		}
-		if (this.items[name].length === 0) delete this.items[name];
-	}
-	async trigger(name, event) {
-		if (!this.items[name] || this.items[name].length === 0) return;
-		try {
-			for (let i = 0; i < this.items[name].length; i++) {
-				const listener = this.items[name][i];
-				await this.triggerListener(name, event, listener);
-				if (event.dispatched) {
-					if (event.error) event.error = void 0;
-					return;
-				}
-			}
-		} catch (e) {
-			event.error = e;
-			if (!this.isErrorListenerHook(name)) {
-				await this.trigger(HookName.ERROR, event);
-				if (event.dispatched) {
-					if (event.error) event.error = void 0;
-				}
-			}
-		}
-	}
-	triggerListener(name, event, listener) {
-		if (this.isErrorListenerHook(name)) {
-			if (event.error) return listener(event);
-			return;
-		}
-		return listener(event);
-	}
-	isErrorListenerHook(input) {
-		return input === HookName.ERROR;
-	}
-};
-//#endregion
-//#region src/path/matcher.ts
-function decodeParam(val) {
-	/* istanbul ignore next */
-	if (typeof val !== "string" || val.length === 0) return val;
-	try {
-		return decodeURIComponent(val);
-	} catch {
-		return val;
-	}
-}
-var PathMatcher = class {
-	path;
-	regexp;
-	regexpKeys = [];
-	regexpOptions;
-	constructor(path, options) {
-		this.path = path;
-		this.regexpOptions = options || {};
-		const regexp = pathToRegexp(path, options);
-		this.regexp = regexp.regexp;
-		this.regexpKeys = regexp.keys;
-	}
-	test(path) {
-		return this.regexp.test(path);
-	}
-	exec(path) {
-		if (this.path === "/" && this.regexpOptions.end === false) return {
-			path: "/",
-			params: Object.create(null)
-		};
-		const match = this.regexp.exec(path);
-		if (!match) return;
-		const params = Object.create(null);
-		for (let i = 1; i < match.length; i++) {
-			const key = this.regexpKeys[i - 1];
-			if (!key) continue;
-			const prop = key.name;
-			const val = decodeParam(match[i]);
-			if (typeof val !== "undefined") params[prop] = val;
-		}
-		return {
-			path: match[0],
-			params
-		};
-	}
-};
-//#endregion
-//#region src/path/utils.ts
-function isPath(input) {
-	return typeof input === "string";
-}
-//#endregion
-//#region src/response/helpers/cache.ts
-function setResponseCacheHeaders(event, options) {
-	options = options || {};
-	const cacheControls = ["public"].concat(options.cacheControls || []);
-	if (options.maxAge !== void 0) cacheControls.push(`max-age=${+options.maxAge}`, `s-maxage=${+options.maxAge}`);
-	if (options.modifiedTime) {
-		const modifiedTime = typeof options.modifiedTime === "string" ? new Date(options.modifiedTime) : options.modifiedTime;
-		event.response.headers.set("last-modified", modifiedTime.toUTCString());
-	}
-	event.response.headers.set("cache-control", cacheControls.join(", "));
-}
-//#endregion
-//#region src/response/helpers/event-stream/utils.ts
-function stripNewlines(value) {
-	return value.replace(/[\r\n]/g, "");
-}
-function serializeEventStreamMessage(message) {
-	let result = "";
-	if (message.id) result += `id: ${stripNewlines(message.id)}\n`;
-	if (message.event) result += `event: ${stripNewlines(message.event)}\n`;
-	if (typeof message.retry === "number" && Number.isInteger(message.retry)) result += `retry: ${message.retry}\n`;
-	const lines = message.data.replace(/\r/g, "").split("\n");
-	for (const line of lines) result += `data: ${line}\n`;
-	result += "\n";
-	return result;
-}
-//#endregion
-//#region src/response/helpers/event-stream/module.ts
-function createEventStream(event, options) {
-	if (options?.maxMessageSize !== void 0) {
-		if (!Number.isInteger(options.maxMessageSize) || options.maxMessageSize < 0) throw new RoutupError("maxMessageSize must be a non-negative integer.");
-	}
-	let controller;
-	let closed = false;
-	const encoder = new TextEncoder();
-	const stream = new ReadableStream({
-		start(ctrl) {
-			controller = ctrl;
-		},
-		cancel() {
-			closed = true;
-		}
-	});
-	const headers = new Headers(event.response.headers);
-	headers.set(HeaderName.CONTENT_TYPE, "text/event-stream");
-	headers.set(HeaderName.CACHE_CONTROL, "private, no-cache, no-store, no-transform, must-revalidate, max-age=0");
-	headers.set(HeaderName.X_ACCEL_BUFFERING, "no");
-	headers.set(HeaderName.CONNECTION, "keep-alive");
-	const handle = {
-		write(message) {
-			if (closed) return;
-			if (typeof message === "string") {
-				handle.write({ data: message });
-				return;
-			}
-			const serialized = serializeEventStreamMessage(message);
-			if (options?.maxMessageSize !== void 0) {
-				if (encoder.encode(serialized).byteLength > options.maxMessageSize) return;
-			}
-			controller.enqueue(encoder.encode(serialized));
-		},
-		end() {
-			if (closed) return;
-			closed = true;
-			controller.close();
-		},
-		response: new Response(stream, {
-			status: event.response.status,
-			statusText: event.response.statusText,
-			headers
-		})
-	};
-	return handle;
-}
-//#endregion
-//#region src/response/helpers/gone.ts
-function isResponseGone(event) {
-	return event.dispatched;
-}
-function setResponseGone(event) {
-	event.dispatched = true;
-}
-//#endregion
-//#region src/response/helpers/header.ts
-function appendResponseHeader(event, name, value) {
-	const { headers } = event.response;
-	if (Array.isArray(value)) for (const v of value) headers.append(name, sanitizeHeaderValue(v));
-	else headers.append(name, sanitizeHeaderValue(value));
-}
-function appendResponseHeaderDirective(event, name, value) {
-	const { headers } = event.response;
-	const existing = headers.get(name);
-	if (!existing) {
-		if (Array.isArray(value)) headers.set(name, sanitizeHeaderValue(value.join("; ")));
-		else headers.set(name, sanitizeHeaderValue(value));
-		return;
-	}
-	const directives = existing.split("; ");
-	if (Array.isArray(value)) directives.push(...value);
-	else directives.push(value);
-	const unique = [...new Set(directives)];
-	headers.set(name, sanitizeHeaderValue(unique.join("; ")));
-}
-//#endregion
-//#region src/response/helpers/utils.ts
-function setResponseContentTypeByFileName(event, fileName) {
-	const ext = extname(fileName);
-	if (ext) {
-		let type = getMimeType(ext.substring(1));
-		if (type) {
-			const charset = getCharsetForMimeType(type);
-			if (charset) type += `; charset=${charset}`;
-			event.response.headers.set(HeaderName.CONTENT_TYPE, type);
-		}
-	}
-}
-//#endregion
-//#region src/response/helpers/header-attachment.ts
-function sanitizeFilename(filename) {
-	return filename.replace(/[\r\n]/g, "");
-}
-function toAsciiFilename(filename) {
-	return filename.replace(/[^\x20-\x7E]/g, "").replace(/"/g, "\\\"");
-}
-function encodeRfc5987(filename) {
-	return encodeURIComponent(filename).replace(/['()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/\*/g, "%2A");
-}
-function setResponseHeaderAttachment(event, filename) {
-	if (typeof filename === "string") setResponseContentTypeByFileName(event, filename);
-	let disposition = "attachment";
-	if (filename) {
-		const sanitized = sanitizeFilename(filename);
-		const ascii = toAsciiFilename(sanitized);
-		disposition += `; filename="${ascii}"`;
-		disposition += `; filename*=UTF-8''${encodeRfc5987(sanitized)}`;
-	}
-	event.response.headers.set(HeaderName.CONTENT_DISPOSITION, disposition);
-}
-//#endregion
-//#region src/response/helpers/header-content-type.ts
-function setResponseHeaderContentType(event, input, ifNotExists) {
-	if (ifNotExists) {
-		if (event.response.headers.get(HeaderName.CONTENT_TYPE)) return;
-	}
-	const contentType = getMimeType(input);
-	if (contentType) event.response.headers.set(HeaderName.CONTENT_TYPE, contentType);
-}
-//#endregion
-//#region src/router-options/module.ts
-const defaults = {
-	trustProxy: () => false,
-	subdomainOffset: 2,
-	etag: buildEtagFn(),
-	proxyIpMax: 0
-};
-const instances = {};
-function setRouterOptions(id, input) {
-	instances[id] = input;
-}
-function findRouterOption(key, path) {
-	if (!path || path.length === 0) return defaults[key];
-	if (path.length > 0) for (let i = path.length; i >= 0; i--) {
-		const segment = path[i];
-		if (segment !== void 0 && hasOwnProperty(instances, segment) && typeof instances[segment][key] !== "undefined") return instances[segment][key];
-	}
-	return defaults[key];
-}
-//#endregion
-//#region src/response/to-response.ts
-function stripWeakPrefix(etag) {
-	return etag.startsWith("W/") ? etag.slice(2) : etag;
-}
-async function applyEtag(body, event, headers) {
-	const etagFn = findRouterOption("etag", event.routerPath);
-	if (!etagFn) return void 0;
-	const etag = await etagFn(body);
-	if (!etag) return void 0;
-	headers.set("etag", etag);
-	const ifNoneMatch = event.headers.get("if-none-match");
-	if (ifNoneMatch && (ifNoneMatch === "*" || ifNoneMatch.split(",").some((t) => stripWeakPrefix(t.trim()) === stripWeakPrefix(etag)))) return new Response(null, {
-		status: 304,
-		headers
-	});
-}
-async function toResponse(value, event) {
-	if (value === void 0) return;
-	if (value === null) return new Response(null, {
-		status: event.response.status,
-		statusText: event.response.statusText,
-		headers: event.response.headers
-	});
-	if (value instanceof Response) return value;
-	const { status, headers, statusText } = event.response;
-	if (typeof value === "string") {
-		if (!headers.has("content-type")) headers.set("content-type", "text/plain; charset=utf-8");
-		const cached = await applyEtag(value, event, headers);
-		if (cached) return cached;
-		return new Response(value, {
-			status,
-			statusText,
-			headers
-		});
-	}
-	if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
-		if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
-		return new Response(value, {
-			status,
-			statusText,
-			headers
-		});
-	}
-	if (value instanceof ReadableStream) return new Response(value, {
-		status,
-		statusText,
-		headers
-	});
-	if (value instanceof Blob) {
-		if (!headers.has("content-type")) headers.set("content-type", value.type || "application/octet-stream");
-		return new Response(value, {
-			status,
-			statusText,
-			headers
-		});
-	}
-	if (!headers.has("content-type")) headers.set("content-type", "application/json; charset=utf-8");
-	const json = JSON.stringify(value);
 	const cached = await applyEtag(json, event, headers);
 	if (cached) return cached;
 	return new Response(json, {
 		status,
-		statusText,
 		headers
 	});
 }
@@ -683,16 +451,12 @@ async function toResponse(value, event) {
 //#region src/response/helpers/send-accepted.ts
 async function sendAccepted(event, data) {
 	event.response.status = 202;
-	event.response.statusText = "Accepted";
-	event.dispatched = true;
 	return await toResponse(data ?? "", event);
 }
 //#endregion
 //#region src/response/helpers/send-created.ts
 async function sendCreated(event, data) {
 	event.response.status = 201;
-	event.response.statusText = "Created";
-	event.dispatched = true;
 	return await toResponse(data ?? "", event);
 }
 //#endregion
@@ -718,133 +482,438 @@ async function sendFile(event, options) {
 			contentOptions.start = Number.isFinite(parsedStart) && parsedStart >= 0 ? parsedStart : 0;
 			contentOptions.end = Number.isFinite(parsedEnd) && parsedEnd >= 0 ? Math.min(parsedEnd, stats.size - 1) : stats.size - 1;
 			if (contentOptions.start >= stats.size || contentOptions.start > contentOptions.end) {
-				event.dispatched = true;
 				const rangeHeaders = new Headers(headers);
 				rangeHeaders.set(HeaderName.CONTENT_RANGE, `bytes */${stats.size}`);
 				return new Response(null, {
 					status: 416,
-					statusText: event.response.statusText,
 					headers: rangeHeaders
 				});
 			}
-			headers.set(HeaderName.CONTENT_RANGE, `bytes ${contentOptions.start}-${contentOptions.end}/${stats.size}`);
-			headers.set(HeaderName.CONTENT_LENGTH, `${contentOptions.end - contentOptions.start + 1}`);
-			statusCode = 206;
-		} else headers.set(HeaderName.CONTENT_LENGTH, `${stats.size}`);
-		headers.set(HeaderName.ACCEPT_RANGES, "bytes");
-		if (stats.mtime) {
-			const mtime = new Date(stats.mtime);
-			headers.set(HeaderName.LAST_MODIFIED, mtime.toUTCString());
-			headers.set(HeaderName.ETag, `W/"${stats.size}-${mtime.getTime()}"`);
+			headers.set(HeaderName.CONTENT_RANGE, `bytes ${contentOptions.start}-${contentOptions.end}/${stats.size}`);
+			headers.set(HeaderName.CONTENT_LENGTH, `${contentOptions.end - contentOptions.start + 1}`);
+			statusCode = 206;
+		} else headers.set(HeaderName.CONTENT_LENGTH, `${stats.size}`);
+		headers.set(HeaderName.ACCEPT_RANGES, "bytes");
+		if (stats.mtime) {
+			const mtime = new Date(stats.mtime);
+			headers.set(HeaderName.LAST_MODIFIED, mtime.toUTCString());
+			headers.set(HeaderName.ETag, `W/"${stats.size}-${mtime.getTime()}"`);
+		}
+	}
+	const content = await options.content(contentOptions);
+	return new Response(content, {
+		status: statusCode,
+		headers
+	});
+}
+//#endregion
+//#region src/request/helpers/header.ts
+function getRequestHeader(event, name) {
+	return event.headers.get(name);
+}
+//#endregion
+//#region src/request/helpers/negotiator.ts
+const NEGOTIATOR_KEY = Symbol.for("routup:negotiator");
+function headersToPlainObject(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+function useRequestNegotiator(event) {
+	let value = event.store[NEGOTIATOR_KEY];
+	if (value) return value;
+	value = new Negotiator({ headers: headersToPlainObject(event.headers) });
+	event.store[NEGOTIATOR_KEY] = value;
+	return value;
+}
+//#endregion
+//#region src/request/helpers/header-accept.ts
+function getRequestAcceptableContentTypes(event) {
+	return useRequestNegotiator(event).mediaTypes();
+}
+function getRequestAcceptableContentType(event, input) {
+	input = input || [];
+	const items = Array.isArray(input) ? input : [input];
+	if (items.length === 0) return getRequestAcceptableContentTypes(event).shift();
+	if (!getRequestHeader(event, HeaderName.ACCEPT)) return items[0];
+	let polluted = false;
+	const mimeTypes = [];
+	for (const item of items) {
+		const mimeType = getMimeType(item);
+		if (mimeType) mimeTypes.push(mimeType);
+		else polluted = true;
+	}
+	const matches = useRequestNegotiator(event).mediaTypes(mimeTypes);
+	if (matches.length > 0) {
+		if (polluted) return items[0];
+		return items[mimeTypes.indexOf(matches[0])];
+	}
+}
+//#endregion
+//#region src/response/helpers/send-format.ts
+function sendFormat(event, input) {
+	const { default: formatDefault, ...formats } = input;
+	const contentTypes = Object.keys(formats);
+	if (contentTypes.length === 0) return formatDefault();
+	const contentType = getRequestAcceptableContentType(event, contentTypes);
+	if (contentType && formats[contentType]) return formats[contentType]();
+	return formatDefault();
+}
+//#endregion
+//#region src/response/helpers/send-redirect.ts
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function isAllowedRedirectUrl(location) {
+	if (location.startsWith("//")) return false;
+	if (location.startsWith("/") || location.startsWith(".")) return true;
+	try {
+		const url = new URL(location);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return true;
+	}
+}
+function sendRedirect(event, location, statusCode = 302) {
+	if (!isAllowedRedirectUrl(location)) throw new RoutupError({
+		status: 400,
+		message: "Invalid redirect URL scheme."
+	});
+	const sanitizedLocation = sanitizeHeaderValue(location);
+	const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${escapeHtml(location)}"></head></html>`;
+	const headers = new Headers(event.response.headers);
+	headers.set("location", sanitizedLocation);
+	headers.set("content-type", "text/html; charset=utf-8");
+	headers.delete("content-length");
+	return new Response(html, {
+		status: statusCode,
+		headers
+	});
+}
+//#endregion
+//#region src/response/helpers/send-stream.ts
+function sendStream(event, stream) {
+	const { status, headers } = event.response;
+	return new Response(stream, {
+		status,
+		headers
+	});
+}
+//#endregion
+//#region src/event/module.ts
+var RoutupEvent = class {
+	request;
+	params;
+	path;
+	method;
+	mountPath;
+	headers;
+	searchParams;
+	response;
+	store;
+	signal;
+	_context;
+	_routerOptions;
+	constructor(context) {
+		this._context = context;
+		this.request = context.request;
+		this.params = context.params;
+		this.path = context.path;
+		this.method = context.method;
+		this.mountPath = context.mountPath;
+		this.headers = context.headers;
+		this.searchParams = context.searchParams;
+		this.response = context.response;
+		this.store = context.store;
+		this.signal = context.signal;
+	}
+	get routerOptions() {
+		if (!this._routerOptions) this._routerOptions = this._context.routerOptions();
+		return this._routerOptions;
+	}
+	async next(error) {
+		return this._context.next(this, error);
+	}
+};
+//#endregion
+//#region src/dispatcher/module.ts
+var DispatcherEvent = class {
+	request;
+	params;
+	path;
+	method;
+	/**
+	* Collected allowed methods (for OPTIONS).
+	*/
+	methodsAllowed;
+	mountPath;
+	error;
+	routerPath;
+	_dispatched;
+	_response;
+	_store;
+	/**
+	* Cached parsed URL (avoids double-parsing).
+	*/
+	_url;
+	/**
+	* Continuation function for middleware onion model.
+	*/
+	_next;
+	_signal;
+	_signalCleanup;
+	/**
+	* Whether _next has already been called (guard against double-invocation).
+	*/
+	_nextCalled;
+	/**
+	* The cached result of the next handler.
+	*/
+	_nextResult;
+	constructor(request) {
+		this.request = request;
+		this._url = new FastURL(request.url);
+		this.method = request.method;
+		this.path = this._url.pathname;
+		this.mountPath = "/";
+		this.params = {};
+		this.routerPath = [];
+		this.methodsAllowed = /* @__PURE__ */ new Set();
+		this._dispatched = false;
+		this._nextCalled = false;
+	}
+	get response() {
+		if (!this._response) this._response = {
+			status: 200,
+			headers: new Headers()
+		};
+		return this._response;
+	}
+	get signal() {
+		if (!this._signal) this._signal = this.request.signal;
+		return this._signal;
+	}
+	set signal(value) {
+		if (this._signalCleanup) {
+			this._signalCleanup();
+			this._signalCleanup = void 0;
+		}
+		if (value === this.request.signal) {
+			this._signal = value;
+			return;
+		}
+		const controller = new AbortController();
+		const abort = (e) => {
+			const reason = e?.target instanceof AbortSignal ? e.target.reason : void 0;
+			this.request.signal.removeEventListener("abort", abort);
+			value.removeEventListener("abort", abort);
+			controller.abort(reason);
+		};
+		if (this.request.signal.aborted || value.aborted) {
+			const reason = this.request.signal.aborted ? this.request.signal.reason : value.reason;
+			controller.abort(reason);
+		} else {
+			this.request.signal.addEventListener("abort", abort, { once: true });
+			value.addEventListener("abort", abort, { once: true });
+			this._signalCleanup = () => {
+				this.request.signal.removeEventListener("abort", abort);
+				value.removeEventListener("abort", abort);
+			};
+		}
+		this._signal = controller.signal;
+	}
+	get dispatched() {
+		return this._dispatched;
+	}
+	set dispatched(value) {
+		this._dispatched = value;
+	}
+	async next(event, error) {
+		if (this._nextCalled) return this._nextResult;
+		this._nextCalled = true;
+		if (this._next) this._nextResult = this._next(event, error);
+		return this._nextResult;
+	}
+	setNext(fn) {
+		if (fn) this._next = async (event, error) => {
+			return toResponse(await fn(error), event);
+		};
+		else this._next = void 0;
+		this._nextCalled = false;
+		this._nextResult = void 0;
+	}
+	build(signal) {
+		return new RoutupEvent({
+			request: this.request,
+			params: this.params,
+			path: this.path,
+			method: this.method,
+			mountPath: this.mountPath,
+			headers: this.request.headers,
+			searchParams: new URLSearchParams(this._url.search),
+			response: this.response,
+			store: this.store,
+			signal: signal ?? this.signal,
+			routerOptions: () => this.resolveOptions(),
+			next: (event, error) => this.next(event, error)
+		});
+	}
+	get store() {
+		if (!this._store) this._store = Object.create(null);
+		return this._store;
+	}
+	resolveOptions() {
+		const resolved = {
+			trustProxy: () => false,
+			subdomainOffset: 2,
+			etag: buildEtagFn(),
+			proxyIpMax: 0
+		};
+		for (let i = 0; i < this.routerPath.length; i++) {
+			const node = this.routerPath[i];
+			const entries = Object.entries(node.options);
+			for (const entry of entries) {
+				const [key, value] = entry;
+				if (typeof value !== "undefined") resolved[key] = value;
+			}
 		}
+		return resolved;
 	}
-	const content = await options.content(contentOptions);
-	event.dispatched = true;
-	return new Response(content, {
-		status: statusCode,
-		statusText: event.response.statusText,
-		headers
-	});
-}
+};
 //#endregion
-//#region src/request/helpers/header.ts
-function getRequestHeader(event, name) {
-	return event.headers.get(name);
-}
+//#region src/handler/constants.ts
+const HandlerType = {
+	CORE: "core",
+	ERROR: "error"
+};
+const HandlerSymbol = Symbol.for("Handler");
 //#endregion
-//#region src/request/helpers/negotiator.ts
-const NEGOTIATOR_KEY = /* @__PURE__ */ Symbol.for("routup:negotiator");
-function headersToPlainObject(headers) {
-	const result = {};
-	headers.forEach((value, key) => {
-		result[key] = value;
-	});
-	return result;
-}
-function useRequestNegotiator(event) {
-	let value = event.store[NEGOTIATOR_KEY];
-	if (value) return value;
-	value = new Negotiator({ headers: headersToPlainObject(event.headers) });
-	event.store[NEGOTIATOR_KEY] = value;
-	return value;
-}
+//#region src/hook/constants.ts
+const HookName = {
+	REQUEST: "request",
+	RESPONSE: "response",
+	ERROR: "error",
+	CHILD_MATCH: "childMatch",
+	CHILD_DISPATCH_BEFORE: "childDispatchBefore",
+	CHILD_DISPATCH_AFTER: "childDispatchAfter"
+};
 //#endregion
-//#region src/request/helpers/header-accept.ts
-function getRequestAcceptableContentTypes(event) {
-	return useRequestNegotiator(event).mediaTypes();
-}
-function getRequestAcceptableContentType(event, input) {
-	input = input || [];
-	const items = Array.isArray(input) ? input : [input];
-	if (items.length === 0) return getRequestAcceptableContentTypes(event).shift();
-	if (!getRequestHeader(event, HeaderName.ACCEPT)) return items[0];
-	let polluted = false;
-	const mimeTypes = [];
-	for (const item of items) {
-		const mimeType = getMimeType(item);
-		if (mimeType) mimeTypes.push(mimeType);
-		else polluted = true;
+//#region src/hook/module.ts
+var HookManager = class {
+	items;
+	constructor() {
+		this.items = {};
 	}
-	const matches = useRequestNegotiator(event).mediaTypes(mimeTypes);
-	if (matches.length > 0) {
-		if (polluted) return items[0];
-		return items[mimeTypes.indexOf(matches[0])];
+	addListener(name, fn, priority = 0) {
+		this.items[name] = this.items[name] || [];
+		const entry = {
+			fn,
+			priority
+		};
+		let i = 0;
+		while (i < this.items[name].length && this.items[name][i].priority >= priority) i++;
+		this.items[name].splice(i, 0, entry);
+		return () => {
+			this.removeListener(name, fn);
+		};
 	}
-}
-//#endregion
-//#region src/response/helpers/send-format.ts
-function sendFormat(event, input) {
-	const { default: formatDefault, ...formats } = input;
-	const contentTypes = Object.keys(formats);
-	if (contentTypes.length === 0) return formatDefault();
-	const contentType = getRequestAcceptableContentType(event, contentTypes);
-	if (contentType && formats[contentType]) return formats[contentType]();
-	return formatDefault();
-}
+	removeListener(name, fn) {
+		if (!this.items[name]) return;
+		if (typeof fn === "undefined") {
+			delete this.items[name];
+			return;
+		}
+		if (typeof fn === "function") {
+			const index = this.items[name].findIndex((entry) => entry.fn === fn);
+			if (index !== -1) this.items[name].splice(index, 1);
+		}
+		if (this.items[name].length === 0) delete this.items[name];
+	}
+	async trigger(name, event) {
+		if (!this.items[name] || this.items[name].length === 0) return;
+		try {
+			for (let i = 0; i < this.items[name].length; i++) {
+				const { fn } = this.items[name][i];
+				await this.triggerListener(name, event, fn);
+				if (event.dispatched) {
+					if (event.error) event.error = void 0;
+					return;
+				}
+			}
+		} catch (e) {
+			if (!event.error) event.error = createError(e);
+			if (!this.isErrorListenerHook(name)) {
+				await this.trigger(HookName.ERROR, event);
+				if (event.dispatched) {
+					if (event.error) event.error = void 0;
+				}
+			}
+		}
+	}
+	triggerListener(name, event, listener) {
+		if (this.isErrorListenerHook(name)) {
+			if (event.error) return listener(event);
+			return;
+		}
+		return listener(event);
+	}
+	isErrorListenerHook(input) {
+		return input === HookName.ERROR;
+	}
+};
 //#endregion
-//#region src/response/helpers/send-redirect.ts
-function escapeHtml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function isAllowedRedirectUrl(location) {
-	if (location.startsWith("//")) return false;
-	if (location.startsWith("/") || location.startsWith(".")) return true;
+//#region src/path/matcher.ts
+function decodeParam(val) {
+	/* istanbul ignore next */
+	if (typeof val !== "string" || val.length === 0) return val;
 	try {
-		const url = new URL(location);
-		return url.protocol === "http:" || url.protocol === "https:";
+		return decodeURIComponent(val);
 	} catch {
-		return true;
+		return val;
 	}
 }
-function sendRedirect(event, location, statusCode = 302) {
-	if (!isAllowedRedirectUrl(location)) throw new RoutupError({
-		statusCode: 400,
-		statusMessage: "Invalid redirect URL scheme."
-	});
-	const sanitizedLocation = sanitizeHeaderValue(location);
-	const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${escapeHtml(location)}"></head></html>`;
-	const headers = new Headers(event.response.headers);
-	headers.set("location", sanitizedLocation);
-	headers.set("content-type", "text/html; charset=utf-8");
-	headers.delete("content-length");
-	const response = new Response(html, {
-		status: statusCode,
-		statusText: event.response.statusText,
-		headers
-	});
-	event.dispatched = true;
-	return response;
-}
+var PathMatcher = class {
+	path;
+	regexp;
+	regexpKeys = [];
+	regexpOptions;
+	constructor(path, options) {
+		this.path = path;
+		this.regexpOptions = options || {};
+		const regexp = pathToRegexp(path, options);
+		this.regexp = regexp.regexp;
+		this.regexpKeys = regexp.keys;
+	}
+	test(path) {
+		return this.regexp.test(path);
+	}
+	exec(path) {
+		if (this.path === "/" && this.regexpOptions.end === false) return {
+			path: "/",
+			params: Object.create(null)
+		};
+		const match = this.regexp.exec(path);
+		if (!match) return;
+		const params = Object.create(null);
+		for (let i = 1; i < match.length; i++) {
+			const key = this.regexpKeys[i - 1];
+			if (!key) continue;
+			const prop = key.name;
+			const val = decodeParam(match[i]);
+			if (typeof val !== "undefined") params[prop] = val;
+		}
+		return {
+			path: match[0],
+			params
+		};
+	}
+};
 //#endregion
-//#region src/response/helpers/send-stream.ts
-function sendStream(event, stream) {
-	event.dispatched = true;
-	const { status, statusText, headers } = event.response;
-	return new Response(stream, {
-		status,
-		statusText,
-		headers
-	});
+//#region src/path/utils.ts
+function isPath(input) {
+	return typeof input === "string";
 }
 //#endregion
 //#region src/handler/module.ts
@@ -884,10 +953,37 @@ var Handler = class {
 		let response;
 		try {
 			let result;
-			if (this.config.type === HandlerType.ERROR) {
-				if (event.error) result = await this.config.fn(event.error, event);
-			} else result = await this.config.fn(event);
-			response = await toResponse(result, event);
+			const previewEvent = event.build();
+			const effectiveTimeout = this.resolveTimeout(previewEvent.routerOptions);
+			let childController;
+			let cleanupParentListener;
+			let handlerEvent = previewEvent;
+			if (effectiveTimeout) {
+				const parentSignal = event.signal;
+				childController = new AbortController();
+				if (parentSignal.aborted) childController.abort(parentSignal.reason);
+				else {
+					const onAbort = () => childController.abort(parentSignal.reason);
+					parentSignal.addEventListener("abort", onAbort, { once: true });
+					cleanupParentListener = () => parentSignal.removeEventListener("abort", onAbort);
+				}
+				handlerEvent = event.build(childController.signal);
+			}
+			try {
+				if (this.config.type === HandlerType.ERROR) {
+					if (event.error) {
+						const { fn } = this.config;
+						const { error } = event;
+						result = await this.executeWithTimeout(() => fn(error, handlerEvent), handlerEvent.routerOptions, childController);
+					}
+				} else {
+					const { fn } = this.config;
+					result = await this.executeWithTimeout(() => fn(handlerEvent), handlerEvent.routerOptions, childController);
+				}
+			} finally {
+				if (cleanupParentListener) cleanupParentListener();
+			}
+			response = await toResponse(result, handlerEvent);
 			if (response) event.dispatched = true;
 		} catch (e) {
 			event.error = isError(e) ? e : createError(e);
@@ -919,6 +1015,33 @@ var Handler = class {
 		this.config.method = method;
 		this._method = method;
 	}
+	async executeWithTimeout(fn, routerOptions, controller) {
+		const effectiveTimeout = this.resolveTimeout(routerOptions);
+		if (!effectiveTimeout) return fn();
+		let timerId;
+		try {
+			return await Promise.race([fn(), new Promise((_, reject) => {
+				timerId = setTimeout(() => {
+					if (controller) controller.abort();
+					reject(createError({
+						status: 408,
+						message: "Request Timeout"
+					}));
+				}, effectiveTimeout);
+			})]);
+		} finally {
+			clearTimeout(timerId);
+		}
+	}
+	resolveTimeout(routerOptions) {
+		const routerDefault = routerOptions.handlerTimeout;
+		const handlerOverride = this.config.timeout;
+		if (!routerDefault && !handlerOverride) return;
+		if (!routerDefault) return handlerOverride;
+		if (!handlerOverride) return routerDefault;
+		if (routerOptions.handlerTimeoutOverridable) return handlerOverride;
+		return Math.min(routerDefault, handlerOverride);
+	}
 	mountHooks() {
 		if (this.config.onBefore) this.hookManager.addListener(HookName.CHILD_DISPATCH_BEFORE, this.config.onBefore);
 		if (this.config.onAfter) this.hookManager.addListener(HookName.CHILD_DISPATCH_AFTER, this.config.onAfter);
@@ -1028,7 +1151,7 @@ function createNodeBridge(handler, isMiddleware) {
 		if (!node?.req || !node?.res) throw new RoutupError("fromNodeHandler/fromNodeMiddleware requires a Node.js runtime.");
 		const req = node.req;
 		const res = node.res;
-		if ((isMiddleware ? await callMiddleware(handler, req, res) : await callHandler(handler, req, res)) === kHandled) event.dispatched = true;
+		if ((isMiddleware ? await callMiddleware(handler, req, res) : await callHandler(handler, req, res)) === kHandled) return null;
 	}) });
 }
 /**
@@ -1084,47 +1207,6 @@ function isHandler(input) {
 	return isInstance(input, HandlerSymbol);
 }
 //#endregion
-//#region src/request/helpers/body.ts
-const BODY_KEY = /* @__PURE__ */ Symbol.for("routup:body");
-/**
-* Read and parse the request body.
-*
-* - `application/x-www-form-urlencoded` → plain object (duplicate keys become arrays)
-* - `application/json` or other → attempts JSON parse, returns undefined on failure
-*
-* The result is cached on the event store — calling `readBody()` multiple
-* times returns the same parsed result.
-*
-* For binary or streaming access, use `event.request.arrayBuffer()`,
-* `event.request.blob()`, or `event.request.body` directly.
-*
-* @experimental
-*/
-async function readBody(event) {
-	if (BODY_KEY in event.store) return event.store[BODY_KEY];
-	const text = await event.request.text();
-	let result;
-	if ((event.headers.get("content-type") || "").includes("application/x-www-form-urlencoded")) result = parseURLEncodedBody(text);
-	else try {
-		result = JSON.parse(text);
-	} catch {
-		result = void 0;
-	}
-	event.store[BODY_KEY] = result;
-	return result;
-}
-function parseURLEncodedBody(body) {
-	const form = new URLSearchParams(body);
-	const parsed = Object.create(null);
-	for (const [key, value] of form.entries()) {
-		const existing = parsed[key];
-		if (existing !== void 0) if (Array.isArray(existing)) existing.push(value);
-		else parsed[key] = [existing, value];
-		else parsed[key] = value;
-	}
-	return parsed;
-}
-//#endregion
 //#region src/request/helpers/cache.ts
 function isRequestCacheable(event, modifiedTime) {
 	const modifiedSince = event.headers.get(HeaderName.IF_MODIFIED_SINCE);
@@ -1179,7 +1261,7 @@ function matchRequestContentType(event, contentType) {
 function getRequestHostName(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = findRouterOption("trustProxy", event.routerPath);
+	else trustProxy = event.routerOptions.trustProxy;
 	let hostname = event.headers.get(HeaderName.X_FORWARDED_HOST);
 	if (!hostname || !event.request.ip || !trustProxy(event.request.ip, 0)) hostname = event.headers.get(HeaderName.HOST);
 	else if (hostname && hostname.includes(",")) hostname = hostname.substring(0, hostname.indexOf(",")).trimEnd();
@@ -1202,7 +1284,7 @@ function getRequestHostName(event, options = {}) {
 function getRequestIP(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = findRouterOption("trustProxy", event.routerPath);
+	else trustProxy = event.routerOptions.trustProxy;
 	const socketAddr = event.request.ip;
 	if (!socketAddr) return;
 	const forwarded = event.headers.get(HeaderName.X_FORWARDED_FOR);
@@ -1222,7 +1304,7 @@ function getRequestIP(event, options = {}) {
 function getRequestProtocol(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = findRouterOption("trustProxy", event.routerPath);
+	else trustProxy = event.routerOptions.trustProxy;
 	let protocol;
 	try {
 		if (new URL(event.request.url).protocol === "https:") protocol = "https";
@@ -1239,6 +1321,59 @@ function getRequestProtocol(event, options = {}) {
 	return protocol;
 }
 //#endregion
+//#region src/plugin/error/constants.ts
+const PluginErrorCode = {
+	PLUGIN: "PLUGIN",
+	NOT_INSTALLED: "PLUGIN_NOT_INSTALLED",
+	INSTALL: "PLUGIN_INSTALL"
+};
+//#endregion
+//#region src/plugin/error/is.ts
+const PLUGIN_ERROR_CODES = new Set(Object.values(PluginErrorCode));
+function isPluginError(input) {
+	if (!isError(input)) return false;
+	return PLUGIN_ERROR_CODES.has(input.code);
+}
+//#endregion
+//#region src/plugin/error/module.ts
+var PluginError = class extends RoutupError {
+	constructor(input = {}) {
+		const options = typeof input === "string" ? { message: input } : { ...input };
+		if (!("code" in options) || !options.code) options.code = PluginErrorCode.PLUGIN;
+		super(options);
+		this.name = "PluginError";
+	}
+};
+//#endregion
+//#region src/plugin/error/sub/install.ts
+var PluginInstallError = class extends PluginError {
+	pluginName;
+	constructor(pluginName, cause) {
+		super({
+			message: `Failed to install plugin "${pluginName}".`,
+			code: PluginErrorCode.INSTALL,
+			cause
+		});
+		this.name = "PluginInstallError";
+		this.pluginName = pluginName;
+	}
+};
+//#endregion
+//#region src/plugin/error/sub/not-installed.ts
+var PluginNotInstalledError = class extends PluginError {
+	pluginName;
+	helperName;
+	constructor(pluginName, helperName) {
+		super({
+			message: `${helperName}() requires the "${pluginName}" plugin. Register it with: router.use(${pluginName}())`,
+			code: PluginErrorCode.NOT_INSTALLED
+		});
+		this.name = "PluginNotInstalledError";
+		this.pluginName = pluginName;
+		this.helperName = helperName;
+	}
+};
+//#endregion
 //#region src/plugin/is.ts
 function isPlugin(input) {
 	if (!isObject(input)) return false;
@@ -1246,30 +1381,31 @@ function isPlugin(input) {
 	return typeof input.install === "function" && input.install.length === 1;
 }
 //#endregion
-//#region src/router-options/normalize.ts
+//#region src/router/options.ts
 function normalizeRouterOptions(input) {
 	if (typeof input.etag !== "undefined") input.etag = buildEtagFn(input.etag);
 	if (typeof input.trustProxy !== "undefined") input.trustProxy = buildTrustProxyFn(input.trustProxy);
+	if (typeof input.timeout !== "undefined") {
+		if (typeof input.timeout !== "number" || !Number.isFinite(input.timeout) || input.timeout <= 0) delete input.timeout;
+	}
+	if (typeof input.handlerTimeout !== "undefined") {
+		if (typeof input.handlerTimeout !== "number" || !Number.isFinite(input.handlerTimeout) || input.handlerTimeout <= 0) delete input.handlerTimeout;
+	}
 	return input;
 }
 //#endregion
 //#region src/router/constants.ts
-const RouterSymbol = /* @__PURE__ */ Symbol.for("Router");
-let RouterPipelineStep = /* @__PURE__ */ function(RouterPipelineStep) {
-	RouterPipelineStep[RouterPipelineStep["START"] = 0] = "START";
-	RouterPipelineStep[RouterPipelineStep["LOOKUP"] = 1] = "LOOKUP";
-	RouterPipelineStep[RouterPipelineStep["CHILD_BEFORE"] = 2] = "CHILD_BEFORE";
-	RouterPipelineStep[RouterPipelineStep["CHILD_DISPATCH"] = 3] = "CHILD_DISPATCH";
-	RouterPipelineStep[RouterPipelineStep["CHILD_AFTER"] = 4] = "CHILD_AFTER";
-	RouterPipelineStep[RouterPipelineStep["FINISH"] = 5] = "FINISH";
-	return RouterPipelineStep;
-}({});
+const RouterSymbol = Symbol.for("Router");
+const RouterPipelineStep = {
+	START: 0,
+	LOOKUP: 1,
+	CHILD_BEFORE: 2,
+	CHILD_DISPATCH: 3,
+	CHILD_AFTER: 4,
+	FINISH: 5
+};
 //#endregion
 //#region src/router/utils.ts
-let nextId = 0;
-function generateRouterID() {
-	return ++nextId;
-}
 function isRouterInstance(input) {
 	return isInstance(input, RouterSymbol);
 }
@@ -1288,10 +1424,6 @@ function acceptsJson(request) {
 var Router = class Router {
 	"@instanceof" = RouterSymbol;
 	/**
-	* An identifier for the router instance.
-	*/
-	id;
-	/**
 	* A label for the router instance.
 	*/
 	name;
@@ -1313,12 +1445,15 @@ var Router = class Router {
 	* @protected
 	*/
 	hookManager;
-	constructor(options = {}) {
-		this.id = generateRouterID();
-		this.name = options.name;
+	/**
+	* Normalized options for this router instance.
+	*/
+	_options;
+	constructor(input = {}) {
+		this.name = input.name;
 		this.hookManager = new HookManager();
-		this.setPath(options.path);
-		setRouterOptions(this.id, normalizeRouterOptions(options));
+		this._options = normalizeRouterOptions(input);
+		this.setPath(input.path);
 	}
 	matchPath(path) {
 		if (this.pathMatcher) return this.pathMatcher.test(path);
@@ -1332,23 +1467,37 @@ var Router = class Router {
 		this.pathMatcher = new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), { end: false });
 	}
 	/**
-	* Public entry point — creates a RoutupEvent from the request,
+	* Public entry point — creates a DispatcherEvent from the request,
 	* runs the pipeline, and returns a Response (with 404/500 fallbacks).
 	*/
 	async fetch(request) {
-		const event = new RoutupEvent(request);
+		const event = new DispatcherEvent(request);
 		let response;
 		try {
-			response = await this.dispatch(event);
+			const timeoutMs = this._options.timeout;
+			if (timeoutMs) {
+				const controller = new AbortController();
+				event.signal = controller.signal;
+				let timerId;
+				try {
+					response = await Promise.race([this.dispatch(event), new Promise((_, reject) => {
+						timerId = setTimeout(() => {
+							controller.abort();
+							reject(createError({
+								status: 408,
+								message: "Request Timeout"
+							}));
+						}, timeoutMs);
+					})]);
+				} finally {
+					clearTimeout(timerId);
+				}
+			} else response = await this.dispatch(event);
 		} catch (e) {
 			event.error = createError(e);
 		}
 		if (response) return response;
-		if (event.error) {
-			const status = event.error.statusCode || 500;
-			const message = event.error.statusMessage || "Internal Server Error";
-			return this.buildFallbackResponse(request, event, status, message);
-		}
+		if (event.error) return this.buildFallbackResponse(request, event, event.error.status || 500, event.error.message);
 		return this.buildFallbackResponse(request, event, 404, "Not Found");
 	}
 	buildFallbackResponse(request, event, status, message) {
@@ -1360,33 +1509,42 @@ var Router = class Router {
 				message
 			}), {
 				status,
-				statusText: message,
 				headers
 			});
 		}
 		headers.set("content-type", "text/plain; charset=utf-8");
 		return new Response(message, {
 			status,
-			statusText: message,
 			headers
 		});
 	}
 	async executePipelineStep(context) {
-		switch (context.step) {
-			case RouterPipelineStep.START: return this.executePipelineStepStart(context);
-			case RouterPipelineStep.LOOKUP: return this.executePipelineStepLookup(context);
-			case RouterPipelineStep.CHILD_BEFORE: return this.executePipelineStepChildBefore(context);
-			case RouterPipelineStep.CHILD_DISPATCH: return this.executePipelineStepChildDispatch(context);
-			case RouterPipelineStep.CHILD_AFTER: return this.executePipelineStepChildAfter(context);
-			case RouterPipelineStep.FINISH:
-			default: return this.executePipelineStepFinish(context);
+		while (context.step !== RouterPipelineStep.FINISH) switch (context.step) {
+			case RouterPipelineStep.START:
+				await this.executePipelineStepStart(context);
+				break;
+			case RouterPipelineStep.LOOKUP:
+				await this.executePipelineStepLookup(context);
+				break;
+			case RouterPipelineStep.CHILD_BEFORE:
+				await this.executePipelineStepChildBefore(context);
+				break;
+			case RouterPipelineStep.CHILD_DISPATCH:
+				await this.executePipelineStepChildDispatch(context);
+				break;
+			case RouterPipelineStep.CHILD_AFTER:
+				await this.executePipelineStepChildAfter(context);
+				break;
+			default:
+				context.step = RouterPipelineStep.FINISH;
+				break;
 		}
+		await this.executePipelineStepFinish(context);
 	}
 	async executePipelineStepStart(context) {
 		await this.hookManager.trigger(HookName.REQUEST, context.event);
 		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
 		else context.step = RouterPipelineStep.LOOKUP;
-		return this.executePipelineStep(context);
 	}
 	async executePipelineStepLookup(context) {
 		while (!context.event.dispatched && context.stackIndex < this.stack.length) {
@@ -1397,12 +1555,12 @@ var Router = class Router {
 					continue;
 				}
 				if (item.matchPath(context.event.path)) {
-					if (item.method) context.event.methodsAllowed.push(item.method);
+					if (item.method) context.event.methodsAllowed.add(item.method);
 					if (item.matchMethod(context.event.method)) {
 						await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
 						if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
 						else context.step = RouterPipelineStep.CHILD_BEFORE;
-						return this.executePipelineStep(context);
+						return;
 					}
 				}
 				context.stackIndex++;
@@ -1412,51 +1570,41 @@ var Router = class Router {
 				await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
 				if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
 				else context.step = RouterPipelineStep.CHILD_BEFORE;
-				return this.executePipelineStep(context);
+				return;
 			}
 			context.stackIndex++;
 		}
 		context.step = RouterPipelineStep.FINISH;
-		return this.executePipelineStep(context);
 	}
 	async executePipelineStepChildBefore(context) {
 		await this.hookManager.trigger(HookName.CHILD_DISPATCH_BEFORE, context.event);
 		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
 		else context.step = RouterPipelineStep.CHILD_DISPATCH;
-		return this.executePipelineStep(context);
 	}
 	async executePipelineStepChildAfter(context) {
 		await this.hookManager.trigger(HookName.CHILD_DISPATCH_AFTER, context.event);
 		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
 		else context.step = RouterPipelineStep.LOOKUP;
-		return this.executePipelineStep(context);
 	}
 	async executePipelineStepChildDispatch(context) {
 		if (context.event.dispatched || typeof this.stack[context.stackIndex] === "undefined") {
 			context.step = RouterPipelineStep.FINISH;
-			return this.executePipelineStep(context);
+			return;
 		}
 		const item = this.stack[context.stackIndex];
 		const { event } = context;
-		const savedNext = event._next;
-		const savedNextCalled = event._nextCalled;
 		try {
-			event._nextCalled = false;
-			event._next = async () => {
+			event.setNext(async (error) => {
+				if (error) event.error = createError(error);
 				const nextContext = {
 					step: RouterPipelineStep.LOOKUP,
 					event,
 					stackIndex: context.stackIndex + 1,
 					response: void 0
 				};
-				event.routerPath.push(this.id);
-				try {
-					await this.executePipelineStep(nextContext);
-				} finally {
-					event.routerPath.pop();
-				}
+				await this.executePipelineStep(nextContext);
 				return nextContext.response;
-			};
+			});
 			const response = await item.dispatch(event);
 			if (response) {
 				context.response = response;
@@ -1465,25 +1613,19 @@ var Router = class Router {
 		} catch (e) {
 			event.error = createError(e);
 			await this.hookManager.trigger(HookName.ERROR, event);
-		} finally {
-			event._next = savedNext;
-			event._nextCalled = savedNextCalled;
 		}
 		context.stackIndex++;
 		context.step = RouterPipelineStep.CHILD_AFTER;
-		return this.executePipelineStep(context);
 	}
 	async executePipelineStepFinish(context) {
 		if (context.event.error || context.event.dispatched) return this.hookManager.trigger(HookName.RESPONSE, context.event);
 		if (!context.event.dispatched && context.event.routerPath.length === 1 && context.event.method && context.event.method === MethodName.OPTIONS) {
-			if (context.event.methodsAllowed.includes(MethodName.GET)) context.event.methodsAllowed.push(MethodName.HEAD);
-			distinctArray(context.event.methodsAllowed);
-			const options = context.event.methodsAllowed.map((key) => key.toUpperCase()).join(",");
+			if (context.event.methodsAllowed.has(MethodName.GET)) context.event.methodsAllowed.add(MethodName.HEAD);
+			const options = [...context.event.methodsAllowed].map((key) => key.toUpperCase()).join(",");
 			const optionsHeaders = new Headers(context.event.response.headers);
 			optionsHeaders.set(HeaderName.ALLOW, options);
 			context.response = new Response(options, {
 				status: context.event.response.status || 200,
-				statusText: context.event.response.statusText,
 				headers: optionsHeaders
 			});
 			context.event.dispatched = true;
@@ -1508,7 +1650,10 @@ var Router = class Router {
 			event,
 			stackIndex: 0
 		};
-		event.routerPath.push(this.id);
+		event.routerPath.push({
+			name: this.name,
+			options: this._options
+		});
 		try {
 			await this.executePipelineStep(context);
 		} finally {
@@ -1598,8 +1743,8 @@ var Router = class Router {
 		else this.use(router);
 		return this;
 	}
-	on(name, fn) {
-		return this.hookManager.addListener(name, fn);
+	on(name, fn, priority) {
+		return this.hookManager.addListener(name, fn, priority);
 	}
 	off(name, fn) {
 		if (typeof fn === "undefined") {
@@ -1611,6 +1756,6 @@ var Router = class Router {
 	}
 };
 //#endregion
-export { isError as $, useRequestNegotiator as A, appendResponseHeaderDirective as B, defineCoreHandler as C, sendFormat as D, sendRedirect as E, toResponse as F, setResponseCacheHeaders as G, setResponseGone as H, setResponseHeaderContentType as I, HandlerSymbol as J, isPath as K, setResponseHeaderAttachment as L, sendFile as M, sendCreated as N, getRequestAcceptableContentType as O, sendAccepted as P, RoutupError as Q, setResponseContentTypeByFileName as R, defineErrorHandler as S, sendStream as T, createEventStream as U, isResponseGone as V, serializeEventStreamMessage as W, RoutupEvent as X, HandlerType as Y, createError as Z, fromWebHandler as _, getRequestHostName as a, fromNodeHandler as b, getRequestAcceptableLanguages as c, getRequestAcceptableCharset as d, HeaderName as et, getRequestAcceptableCharsets as f, isHandlerOptions as g, isHandler as h, getRequestIP as i, getRequestHeader as j, getRequestAcceptableContentTypes as k, getRequestAcceptableEncoding as l, readBody as m, isPlugin as n, matchRequestContentType as o, isRequestCacheable as p, PathMatcher as q, getRequestProtocol as r, getRequestAcceptableLanguage as s, Router as t, MethodName as tt, getRequestAcceptableEncodings as u, isWebHandler as v, Handler as w, fromNodeMiddleware as x, isWebHandlerProvider as y, appendResponseHeader as z };
+export { appendResponseHeaderDirective as $, isPath as A, getRequestAcceptableContentTypes as B, isWebHandler as C, defineErrorHandler as D, fromNodeMiddleware as E, RoutupEvent as F, sendAccepted as G, getRequestHeader as H, sendStream as I, isError as J, toResponse as K, sendRedirect as L, HandlerSymbol as M, HandlerType as N, defineCoreHandler as O, DispatcherEvent as P, appendResponseHeader as Q, sendFormat as R, fromWebHandler as S, fromNodeHandler as T, sendFile as U, useRequestNegotiator as V, sendCreated as W, setResponseHeaderAttachment as X, setResponseHeaderContentType as Y, setResponseContentTypeByFileName as Z, getRequestAcceptableCharset as _, PluginInstallError as a, HeaderName as at, isHandler as b, PluginErrorCode as c, getRequestHostName as d, createEventStream as et, matchRequestContentType as f, getRequestAcceptableEncodings as g, getRequestAcceptableEncoding as h, PluginNotInstalledError as i, setResponseCacheHeaders as it, PathMatcher as j, Handler as k, getRequestProtocol as l, getRequestAcceptableLanguages as m, normalizeRouterOptions as n, ErrorSymbol as nt, PluginError as o, MethodName as ot, getRequestAcceptableLanguage as p, createError as q, isPlugin as r, RoutupError as rt, isPluginError as s, Router as t, serializeEventStreamMessage as tt, getRequestIP as u, getRequestAcceptableCharsets as v, isWebHandlerProvider as w, isHandlerOptions as x, isRequestCacheable as y, getRequestAcceptableContentType as z };
 
-//# sourceMappingURL=src-CNoRH9eg.mjs.map
+//# sourceMappingURL=src-Ck8GklBr.mjs.map