elysia 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/handler/error.mjs

@@ -1,7 +1,8 @@
+// @bun
 import { StatusMap } from "../constants.mjs";
 import { isNotEmpty } from "../utils.mjs";
 import { isProduction } from "../universal/is-production.mjs";
-import { ElysiaStatus, HTTPError, NotFound, PROBLEM_JSON, ValidationError, internalServerErrorResponse, problemBody } from "../error.mjs";
+import { ElysiaStatus, HTTPError, NotFound, PROBLEM_JSON, ValidationError, internalServerErrorResponse, problemBody, titleOf } from "../error.mjs";
 import { materializeSetHeaders } from "../adapter/utils.mjs";
 import { parseQueryFromURL } from "../parse-query.mjs";
 import { getNotFound, hasAsync } from "./utils.mjs";
@@ -30,14 +31,21 @@ function parseQuery(context) {
 	});
 }
 const isPristineNotFound = (context, error) => error instanceof NotFound && error.response === "Not Found" && !context.set.cookie && !isNotEmpty(context.set.headers);
-const claimsProblemType = (error) => typeof error?.type === "string" ? !(error instanceof ValidationError) && error.constructor?.name !== "ValidationError" : error instanceof HTTPError;
+/**
+* Whether an error claims a problem type, judged on `type` as the caller
+* read it once: a getter read again could answer anything else, `undefined`
+* included
+*/
+const claimsProblemType = (error, type) => typeof type === "string" ? !(error instanceof ValidationError) && error.constructor?.name !== "ValidationError" : error instanceof HTTPError;
 function adoptErrorType(result, error) {
 	const body = result?.response;
-	if (typeof error?.type !== "string" || !claimsProblemType(error) || body?.type !== "about:blank" || result.headers?.["content-type"] !== "application/problem+json") return result;
+	const type = error?.type;
+	if (typeof type !== "string" || !claimsProblemType(error, type) || body?.type !== "about:blank" || result.headers?.["content-type"] !== "application/problem+json") return result;
+	const code = error.code;
 	return new ElysiaStatus(result.status, {
 		...body,
-		type: error.type,
-		...typeof error.code === "string" ? { code: error.code } : {}
+		type,
+		...typeof code === "string" ? { code } : {}
 	}, result.headers);
 }
 /**
@@ -54,38 +62,35 @@ function fallbackResponse(context, error, mapResponse) {
 	} catch {}
 	return fallbackErrorResponse(context, error, mapResponse);
 }
-/**
-* Numeric form of an annotated status, which may be written as a name.
-* A numeric string keeps coercing so the production mask below can't be
-* slipped past with `'502'`
-*/
 const resolveStatus = (status) => typeof status === "string" ? StatusMap[status] ?? +status : status;
 /**
 * Body served by an error that carries a status but no usable body:
-* its declared `response`, otherwise its message
+* its declared `response`, otherwise its message, or `mask` in its place
+* on a production 5xx
 */
-function statusFallbackBody(error, status) {
+function statusFallbackBody(error, status, mask = "Internal Server Error") {
 	const masked = isProduction() && status >= 500;
 	const declared = error.response;
-	return declared !== void 0 && !(masked && typeof declared === "object") ? declared : masked ? "Internal Server Error" : error.message ?? "";
+	return declared !== void 0 && !(masked && typeof declared === "object") ? declared : masked ? mask : error.message ?? "";
 }
 /**
 * RFC 9457 problem document carrying `detail` verbatim, mirroring `problem()`.
+* `type` comes in as the value the claim was checked on, and `code` is read
+* once, so a getter can't put anything but a string on the wire
 */
-const problemOf = (self, detail, status, claimsProblem) => new ElysiaStatus(status, problemBody({
-	type: self.type ?? "about:blank",
-	...claimsProblem && typeof self.code === "string" ? { code: self.code } : {},
-	detail,
-	status
-}), { "content-type": PROBLEM_JSON });
+const problemOf = (self, type, detail, status, claimsProblem) => {
+	const code = claimsProblem ? self.code : void 0;
+	return new ElysiaStatus(status, problemBody({
+		type: typeof type === "string" ? type : "about:blank",
+		...typeof code === "string" ? { code } : {},
+		detail,
+		status
+	}), { "content-type": PROBLEM_JSON });
+};
 /**
-* Read one annotation knob.
-*
-* Both knobs are canonically methods, so they're evaluated per serve and may
-* be `async`. Running a stranger's function is side-effect surface (it may
-* consume a stream or do IO), so it takes the same problem claim the shaping
-* does — an unclaimed duck error never invokes one. A *value* annotation stays
-* inert data and keeps duck-participating as it always has
+* Read one annotation knob, a method (may be `async`) or a plain value.
+* A method may have side effects, so only an error claiming a problem type
+* gets it invoked; a plain value is read from any error
 */
 const readAnnotation = (self, key, claimsProblem) => {
 	const annotation = self[key];
@@ -97,7 +102,8 @@ function fallbackErrorResponse(context, error, mapResponse) {
 	const self = error ?? {};
 	const status = resolveStatus(self.status);
 	const owned = error instanceof HTTPError;
-	const claimsProblem = claimsProblemType(error);
+	const type = self.type;
+	const claimsProblem = claimsProblemType(error, type);
 	const served = typeof status === "number" ? status : resolveStatus(context.set.status);
 	const failed = (cause) => {
 		context.set.status = 500;
@@ -108,32 +114,29 @@ function fallbackErrorResponse(context, error, mapResponse) {
 	}
 	const legacy = () => {
 		if (error?.status) return mapResponse(statusFallbackBody(error, status), context.set, context);
-		if (error?.message != null) {
-			if (context.set.status === void 0 || context.set.status === 200) context.set.status = 500;
-			return mapResponse(internalServerErrorResponse(error), context.set, context);
-		}
+		if (error?.message != null && (context.set.status === void 0 || context.set.status === 200)) context.set.status = 500;
 		return mapResponse(internalServerErrorResponse(error), context.set, context);
 	};
 	const serveMessage = () => {
 		if (!claimsProblem) return legacy();
 		mergeHeaders();
-		return mapResponse(problemOf(self, statusFallbackBody(error, served), served, claimsProblem), context.set, context);
+		return mapResponse(problemOf(self, type, statusFallbackBody(error, served, titleOf(served)), served, claimsProblem), context.set, context);
 	};
-	const tier = (key) => {
+	const serveAnnotation = (key) => {
 		let annotation;
 		try {
 			annotation = readAnnotation(self, key, claimsProblem);
 		} catch (cause) {
 			return failed(cause);
 		}
-		if (annotation === void 0) return key === "value" ? tier("detail") : serveMessage();
+		if (annotation === void 0) return key === "value" ? serveAnnotation("detail") : serveMessage();
 		if (annotation instanceof Promise) return annotation.then((resolved) => {
-			if (resolved === void 0) return key === "value" ? tier("detail") : serveMessage();
+			if (resolved === void 0) return key === "value" ? serveAnnotation("detail") : serveMessage();
 			mergeHeaders();
-			return mapResponse(key === "value" ? resolved : problemOf(self, resolved, served, claimsProblem), context.set, context);
+			return mapResponse(key === "value" ? resolved : problemOf(self, type, resolved, served, claimsProblem), context.set, context);
 		}, failed);
 		mergeHeaders();
-		return mapResponse(key === "value" ? annotation : problemOf(self, annotation, served, claimsProblem), context.set, context);
+		return mapResponse(key === "value" ? annotation : problemOf(self, type, annotation, served, claimsProblem), context.set, context);
 	};
 	if (error instanceof ValidationError) return mapResponse(error.type === "response" ? internalServerErrorResponse(void 0) : new ElysiaStatus(422, problemBody({
 		type: "validation",
@@ -141,7 +144,8 @@ function fallbackErrorResponse(context, error, mapResponse) {
 		title: "Validation Error",
 		status: 422
 	}), { "content-type": PROBLEM_JSON }), context.set, context);
-	if (owned || error instanceof Error && typeof status === "number" && status >= 100 && !(isProduction() && status >= 500)) return tier("value");
+	if (owned || error instanceof Error && typeof status === "number" && status >= 100 && !(isProduction() && status >= 500)) return serveAnnotation("value");
+	if (claimsProblem && error instanceof Error && typeof status === "number" && status >= 500) return mapResponse(problemOf(self, type, titleOf(status), status, false), context.set, context);
 	return legacy();
 }
 function applyErrorStatus(context, error) {
@@ -165,7 +169,7 @@ function createErrorHandler(onErrors, mapResponse, allowUnsafe = false) {
 		else if (context.set.status === void 0 || context.set.status === 200) context.set.status = 500;
 		return mapWith(sign)(adoptErrorType(result, error), context.set, context);
 	};
-	const settle = (context, error, sign) => isPristineNotFound(context, error) ? getNotFound() : fallbackResponse(context, error, mapWith(sign));
+	const serveUnhandled = (context, error, sign) => isPristineNotFound(context, error) ? getNotFound() : fallbackResponse(context, error, mapWith(sign));
 	if (hasAsync(onErrors)) return async (context, error, sign) => {
 		materializeSetHeaders(context.set);
 		enter(context, error);
@@ -174,7 +178,7 @@ function createErrorHandler(onErrors, mapResponse, allowUnsafe = false) {
 			if (typeof result?.then === "function") result = await result;
 			if (result !== void 0) return respond(context, error, result, sign);
 		}
-		return settle(context, error, sign);
+		return serveUnhandled(context, error, sign);
 	};
 	return (context, error, sign) => {
 		materializeSetHeaders(context.set);
@@ -183,7 +187,7 @@ function createErrorHandler(onErrors, mapResponse, allowUnsafe = false) {
 			const result = onErrors[i](context);
 			if (result !== void 0) return respond(context, error, result, sign);
 		}
-		return settle(context, error, sign);
+		return serveUnhandled(context, error, sign);
 	};
 }
 

package/dist/handler/fetch.js

@@ -69,7 +69,7 @@ function dispatchResult(result, context, handleError, afterResponse) {
 	if (typeof result?.then === "function") return Promise.resolve(result).catch(catchError(context, handleError, afterResponse));
 	return result;
 }
-function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
+function findRoute(context, request, map, router, onNotFound, handleError, afterResponse, strictPath, hasWS, hasDynamicWS, app) {
 	const path = context.path;
 	const method = request.method;
 	if (hasWS && method === "GET") {
@@ -98,11 +98,11 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 	const found = router?.find(method, path) ?? router?.find("*", path);
 	if (found) {
 		context.params = path.indexOf("%") === -1 ? found.params : decodeParams(found.params);
-		return dispatchResult(found.store(context), context, handleError, afterResponse);
+		const store = found.store;
+		const dynamic = typeof store === "number" ? app["compiled"]?.[store] : store;
+		return dispatchResult(dynamic ? dynamic(context) : app["~dispatch"](store, context), context, handleError, afterResponse);
 	}
-	if (hasError) return finalizeError(context, handleError, afterResponse, new require_error.NotFound());
-	afterResponse?.(context, 404);
-	return notFound(context);
+	return onNotFound(context);
 }
 function createFetchHandler(app) {
 	const Context = require_context.createContext(app);
@@ -143,8 +143,8 @@ function createFetchHandler(app) {
 		} catch {}
 		return pending ? pending.then(() => baseMapResponse(response, set, request, true), () => baseMapResponse(response, set, request, true)) : baseMapResponse(response, set, request, true);
 	}
-	const mapResponseHooks = hook?.mapResponse;
-	const mapResponse = mapResponseHooks?.length ? (response, set, context, sign) => {
+	const plainMap = (response, set, context, sign) => finalMap(response, set, context?.request, sign);
+	function mapWithHooks(mapResponseHooks, response, set, context, sign) {
 		if (!context) return baseMapResponse(response, set, void 0, true);
 		context.responseValue = response;
 		const request = context.request;
@@ -160,8 +160,12 @@ function createFetchHandler(app) {
 			return finalMap(response, set, request, sign);
 		};
 		return run(0);
-	} : (response, set, context, sign) => finalMap(response, set, context?.request, sign);
-	const handleError = require_handler_error.createErrorHandler(hook?.error, mapResponse, app["~config"]?.allowUnsafeValidationDetails);
+	}
+	const mapResponseHooks = hook?.mapResponse;
+	const mapResponse = mapResponseHooks?.length ? mapWithHooks.bind(null, mapResponseHooks) : plainMap;
+	const allowUnsafe = app["~config"]?.allowUnsafeValidationDetails;
+	const handleError = require_handler_error.createErrorHandler(hook?.error, mapResponse, allowUnsafe);
+	const handleRouteError = hook?.error || mapResponseHooks?.length ? require_handler_error.createErrorHandler(void 0, plainMap, allowUnsafe) : handleError;
 	const traceHandlers = hook?.trace;
 	const hasTrace = !!traceHandlers?.length;
 	const traceProvider = hasTrace ? app["~resolvedCapability"]("trace") : void 0;
@@ -169,8 +173,7 @@ function createFetchHandler(app) {
 	const traceRequestPhase = hasTrace && (tracePhases === null || tracePhases.has("request"));
 	const traceAfterResponsePhase = hasTrace && (tracePhases === null || tracePhases.has("afterResponse"));
 	const tracerFactories = hasTrace ? traceHandlers.map((fn) => traceProvider.createTracer(fn)) : void 0;
-	const afterResponses = hook?.afterResponse;
-	const afterResponse = (context, status) => {
+	const afterResponse = (context, status, afterResponses = hook?.afterResponse) => {
 		if (context._arf) return;
 		const queue = context["~afterResponse"];
 		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length && !context["~dispose"]) return;
@@ -182,7 +185,7 @@ function createFetchHandler(app) {
 			let reports;
 			if (traceAfterResponsePhase) {
 				cache = context.trace;
-				if (!cache && tracerFactories) {
+				if (!cache && tracerFactories && afterResponses !== null) {
 					context.rid ??= require_utils.requestId();
 					cache = tracerFactories.map((f) => f(context));
 					context.trace = cache;
@@ -218,7 +221,36 @@ function createFetchHandler(app) {
 		});
 	};
 	const fail = (context, error, sign) => finalizeError(context, handleError, afterResponse, error, sign);
-	app["~finalizeError"] = fail;
+	const routeAfterResponse = (context, status) => afterResponse(context, status, null);
+	const failRoute = (context, error, sign) => finalizeError(context, handleRouteError, routeAfterResponse, error, sign);
+	const routeHandlers = /* @__PURE__ */ new WeakMap();
+	app["~finalizeError"] = (context, error, sign, wholeChain, route) => {
+		if (wholeChain) return fail(context, error, sign);
+		if (!route) return failRoute(context, error, sign);
+		let handle = routeHandlers.get(route);
+		if (!handle) {
+			const withHooks = require_handler_error.createErrorHandler(route.error?.length ? route.error : void 0, route.mapResponse?.length ? mapWithHooks.bind(null, route.mapResponse) : plainMap, allowUnsafe);
+			handle = (context, error, sign) => {
+				const set = context.set;
+				const end = () => handleRouteError(context, set["~signFailed"] ? new require_error.InternalServerError() : error, sign);
+				if (set["~signFailed"]) return end();
+				const signed = (r) => set["~signFailed"] ? end() : r;
+				try {
+					const response = withHooks(context, error, sign);
+					return response instanceof Promise ? response.then(signed, end) : signed(response);
+				} catch {
+					return end();
+				}
+			};
+			routeHandlers.set(route, handle);
+		}
+		return finalizeError(context, handle, routeAfterResponse, error, sign);
+	};
+	const onNotFound = (context) => {
+		if (hasError) return finalizeError(context, handleError, afterResponse, new require_error.NotFound());
+		afterResponse(context, 404);
+		return notFound(context);
+	};
 	if (traceRequestPhase) {
 		const onRequests = hook?.request ?? [];
 		return async (request, server) => {
@@ -240,6 +272,7 @@ function createFetchHandler(app) {
 				begin: performance.now(),
 				total: onRequests.length
 			});
+			let routed = false;
 			try {
 				const endReports = new Array(traceLength);
 				for (let i = 0; i < onRequests.length; i++) {
@@ -268,10 +301,11 @@ function createFetchHandler(app) {
 					}
 				}
 				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i]);
-				return await findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return await findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
 				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i], error);
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 	}
@@ -283,6 +317,7 @@ function createFetchHandler(app) {
 			if (armEager(request, context)) return require_handler_utils.emptyResponse.clone();
 			const path = extractPath(request.url, context);
 			context.server = server ?? null;
+			let routed = false;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
 					let result = onRequests[i](context);
@@ -298,9 +333,10 @@ function createFetchHandler(app) {
 						return response;
 					}
 				}
-				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 		return (request, server) => {
@@ -309,6 +345,7 @@ function createFetchHandler(app) {
 			if (armEager(request, context)) return require_handler_utils.emptyResponse.clone();
 			const path = extractPath(request.url, context);
 			context.server = server ?? null;
+			let routed = false;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
 					const result = onRequests[i](context);
@@ -324,9 +361,10 @@ function createFetchHandler(app) {
 						return response;
 					}
 				}
-				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 	}
@@ -335,9 +373,9 @@ function createFetchHandler(app) {
 		extractPath(request.url, context);
 		context.server = server ?? null;
 		try {
-			return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+			return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 		} catch (error) {
-			return fail(context, error);
+			return failRoute(context, error);
 		}
 	};
 }

package/dist/handler/fetch.mjs

@@ -1,6 +1,7 @@
+// @bun
 import { authorityEnd, flattenChain, isNotEmpty, nullObject, requestId } from "../utils.mjs";
 import { isProduction } from "../universal/is-production.mjs";
-import { NotFound, PROBLEM_JSON, internalServerErrorResponse } from "../error.mjs";
+import { InternalServerError, NotFound, PROBLEM_JSON, internalServerErrorResponse } from "../error.mjs";
 import { handleSet, materializeSetHeaders } from "../adapter/utils.mjs";
 import { drainDisposables, emptyResponse, getNotFound, getNotFoundBody, hasAsync } from "./utils.mjs";
 import { createErrorHandler } from "./error.mjs";
@@ -66,7 +67,7 @@ function dispatchResult(result, context, handleError, afterResponse) {
 	if (typeof result?.then === "function") return Promise.resolve(result).catch(catchError(context, handleError, afterResponse));
 	return result;
 }
-function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
+function findRoute(context, request, map, router, onNotFound, handleError, afterResponse, strictPath, hasWS, hasDynamicWS, app) {
 	const path = context.path;
 	const method = request.method;
 	if (hasWS && method === "GET") {
@@ -95,11 +96,11 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 	const found = router?.find(method, path) ?? router?.find("*", path);
 	if (found) {
 		context.params = path.indexOf("%") === -1 ? found.params : decodeParams(found.params);
-		return dispatchResult(found.store(context), context, handleError, afterResponse);
+		const store = found.store;
+		const dynamic = typeof store === "number" ? app["compiled"]?.[store] : store;
+		return dispatchResult(dynamic ? dynamic(context) : app["~dispatch"](store, context), context, handleError, afterResponse);
 	}
-	if (hasError) return finalizeError(context, handleError, afterResponse, new NotFound());
-	afterResponse?.(context, 404);
-	return notFound(context);
+	return onNotFound(context);
 }
 function createFetchHandler(app) {
 	const Context = createContext(app);
@@ -140,8 +141,8 @@ function createFetchHandler(app) {
 		} catch {}
 		return pending ? pending.then(() => baseMapResponse(response, set, request, true), () => baseMapResponse(response, set, request, true)) : baseMapResponse(response, set, request, true);
 	}
-	const mapResponseHooks = hook?.mapResponse;
-	const mapResponse = mapResponseHooks?.length ? (response, set, context, sign) => {
+	const plainMap = (response, set, context, sign) => finalMap(response, set, context?.request, sign);
+	function mapWithHooks(mapResponseHooks, response, set, context, sign) {
 		if (!context) return baseMapResponse(response, set, void 0, true);
 		context.responseValue = response;
 		const request = context.request;
@@ -157,8 +158,12 @@ function createFetchHandler(app) {
 			return finalMap(response, set, request, sign);
 		};
 		return run(0);
-	} : (response, set, context, sign) => finalMap(response, set, context?.request, sign);
-	const handleError = createErrorHandler(hook?.error, mapResponse, app["~config"]?.allowUnsafeValidationDetails);
+	}
+	const mapResponseHooks = hook?.mapResponse;
+	const mapResponse = mapResponseHooks?.length ? mapWithHooks.bind(null, mapResponseHooks) : plainMap;
+	const allowUnsafe = app["~config"]?.allowUnsafeValidationDetails;
+	const handleError = createErrorHandler(hook?.error, mapResponse, allowUnsafe);
+	const handleRouteError = hook?.error || mapResponseHooks?.length ? createErrorHandler(void 0, plainMap, allowUnsafe) : handleError;
 	const traceHandlers = hook?.trace;
 	const hasTrace = !!traceHandlers?.length;
 	const traceProvider = hasTrace ? app["~resolvedCapability"]("trace") : void 0;
@@ -166,8 +171,7 @@ function createFetchHandler(app) {
 	const traceRequestPhase = hasTrace && (tracePhases === null || tracePhases.has("request"));
 	const traceAfterResponsePhase = hasTrace && (tracePhases === null || tracePhases.has("afterResponse"));
 	const tracerFactories = hasTrace ? traceHandlers.map((fn) => traceProvider.createTracer(fn)) : void 0;
-	const afterResponses = hook?.afterResponse;
-	const afterResponse = (context, status) => {
+	const afterResponse = (context, status, afterResponses = hook?.afterResponse) => {
 		if (context._arf) return;
 		const queue = context["~afterResponse"];
 		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length && !context["~dispose"]) return;
@@ -179,7 +183,7 @@ function createFetchHandler(app) {
 			let reports;
 			if (traceAfterResponsePhase) {
 				cache = context.trace;
-				if (!cache && tracerFactories) {
+				if (!cache && tracerFactories && afterResponses !== null) {
 					context.rid ??= requestId();
 					cache = tracerFactories.map((f) => f(context));
 					context.trace = cache;
@@ -215,7 +219,36 @@ function createFetchHandler(app) {
 		});
 	};
 	const fail = (context, error, sign) => finalizeError(context, handleError, afterResponse, error, sign);
-	app["~finalizeError"] = fail;
+	const routeAfterResponse = (context, status) => afterResponse(context, status, null);
+	const failRoute = (context, error, sign) => finalizeError(context, handleRouteError, routeAfterResponse, error, sign);
+	const routeHandlers = /* @__PURE__ */ new WeakMap();
+	app["~finalizeError"] = (context, error, sign, wholeChain, route) => {
+		if (wholeChain) return fail(context, error, sign);
+		if (!route) return failRoute(context, error, sign);
+		let handle = routeHandlers.get(route);
+		if (!handle) {
+			const withHooks = createErrorHandler(route.error?.length ? route.error : void 0, route.mapResponse?.length ? mapWithHooks.bind(null, route.mapResponse) : plainMap, allowUnsafe);
+			handle = (context, error, sign) => {
+				const set = context.set;
+				const end = () => handleRouteError(context, set["~signFailed"] ? new InternalServerError() : error, sign);
+				if (set["~signFailed"]) return end();
+				const signed = (r) => set["~signFailed"] ? end() : r;
+				try {
+					const response = withHooks(context, error, sign);
+					return response instanceof Promise ? response.then(signed, end) : signed(response);
+				} catch {
+					return end();
+				}
+			};
+			routeHandlers.set(route, handle);
+		}
+		return finalizeError(context, handle, routeAfterResponse, error, sign);
+	};
+	const onNotFound = (context) => {
+		if (hasError) return finalizeError(context, handleError, afterResponse, new NotFound());
+		afterResponse(context, 404);
+		return notFound(context);
+	};
 	if (traceRequestPhase) {
 		const onRequests = hook?.request ?? [];
 		return async (request, server) => {
@@ -237,6 +270,7 @@ function createFetchHandler(app) {
 				begin: performance.now(),
 				total: onRequests.length
 			});
+			let routed = false;
 			try {
 				const endReports = new Array(traceLength);
 				for (let i = 0; i < onRequests.length; i++) {
@@ -265,10 +299,11 @@ function createFetchHandler(app) {
 					}
 				}
 				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i]);
-				return await findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return await findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
 				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i], error);
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 	}
@@ -280,6 +315,7 @@ function createFetchHandler(app) {
 			if (armEager(request, context)) return emptyResponse.clone();
 			const path = extractPath(request.url, context);
 			context.server = server ?? null;
+			let routed = false;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
 					let result = onRequests[i](context);
@@ -295,9 +331,10 @@ function createFetchHandler(app) {
 						return response;
 					}
 				}
-				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 		return (request, server) => {
@@ -306,6 +343,7 @@ function createFetchHandler(app) {
 			if (armEager(request, context)) return emptyResponse.clone();
 			const path = extractPath(request.url, context);
 			context.server = server ?? null;
+			let routed = false;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
 					const result = onRequests[i](context);
@@ -321,9 +359,10 @@ function createFetchHandler(app) {
 						return response;
 					}
 				}
-				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+				routed = true;
+				return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 			} catch (error) {
-				return fail(context, error);
+				return (routed ? failRoute : fail)(context, error);
 			}
 		};
 	}
@@ -332,9 +371,9 @@ function createFetchHandler(app) {
 		extractPath(request.url, context);
 		context.server = server ?? null;
 		try {
-			return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+			return findRoute(context, request, map, router, onNotFound, handleRouteError, routeAfterResponse, strictPath, hasWS, hasDynamicWS, app);
 		} catch (error) {
-			return fail(context, error);
+			return failRoute(context, error);
 		}
 	};
 }

package/dist/handler/utils.d.ts

@@ -9,13 +9,26 @@ declare const emptyResponse: Response | {
 declare function getNotFoundBody(): string;
 declare function getNotFound(): Response;
 declare function forwardError<T>(value: T): T;
+/**
+ * Non-Error classes the route's own error hooks register: like any hook, a
+ * class registered after the route doesn't reach it
+ */
 declare function returnedErrorClasses(hook: {
   error?: unknown;
-} | undefined, root: AnyElysia): Function[] | undefined;
+} | undefined): Function[] | undefined;
 declare const forwardErrorOf: (classes: Function[]) => <T>(value: T) => T;
-declare function finalizeRouteError(app: AnyElysia, context: Partial<Context>, error: unknown, sign?: (set: Context['set']) => unknown): MaybePromise<Response>;
+declare function finalizeRouteError(app: AnyElysia, context: Partial<Context>, error: unknown, sign?: (set: Context['set']) => unknown, route?: RouteErrorHooks): MaybePromise<Response>;
+/**
+ * The hooks a matched route's error ends with: its own, never one the app
+ * registered after it
+ */
+interface RouteErrorHooks {
+  error?: Function[];
+  mapResponse?: Function[];
+}
+declare const finalizeRouteErrorOf: (route: RouteErrorHooks | undefined) => typeof finalizeRouteError;
 declare function registerDeriveDisposable(context: any, value: unknown, scan?: any): void;
 declare function drainDisposables(context: any): Promise<void>;
 declare const hasAsync: (fns: Function[]) => boolean;
 //#endregion
-export { drainDisposables, emptyResponse, finalizeRouteError, forwardError, forwardErrorOf, getNotFound, getNotFoundBody, hasAsync, registerDeriveDisposable, returnedErrorClasses };
+export { RouteErrorHooks, drainDisposables, emptyResponse, finalizeRouteError, finalizeRouteErrorOf, forwardError, forwardErrorOf, getNotFound, getNotFoundBody, hasAsync, registerDeriveDisposable, returnedErrorClasses };

package/dist/handler/utils.js

@@ -38,32 +38,32 @@ function forwardError(value) {
 	if (value instanceof Error) throw value;
 	return value;
 }
-const chainErrorClasses = /* @__PURE__ */ new WeakMap();
-function collectErrorClasses(error, into) {
-	if (!error) return into;
+/**
+* Non-Error classes the route's own error hooks register: like any hook, a
+* class registered after the route doesn't reach it
+*/
+function returnedErrorClasses(hook) {
+	const error = hook?.error;
+	if (!error) return;
+	let into;
 	const list = Array.isArray(error) ? error : [error];
 	for (let i = 0; i < list.length; i++) {
-		const C = list[i]?.["~errorClass"];
-		if (C && !into?.includes(C)) (into ??= []).push(C);
+		const errorClass = list[i]?.["~errorClass"];
+		if (errorClass && !into?.includes(errorClass)) (into ??= []).push(errorClass);
 	}
 	return into;
 }
-function returnedErrorClasses(hook, root) {
-	const head = root["~hookChain"];
-	let rootClasses = head && chainErrorClasses.get(head);
-	if (head && rootClasses === void 0) chainErrorClasses.set(head, rootClasses = collectErrorClasses(require_utils.flattenChain(head)?.error, void 0) ?? null);
-	return collectErrorClasses(hook?.error, rootClasses?.slice());
-}
 const forwardErrorOf = (classes) => (value) => {
 	if (value instanceof Error) throw value;
 	for (let i = 0; i < classes.length; i++) if (value instanceof classes[i]) throw value;
 	return value;
 };
-function finalizeRouteError(app, context, error, sign) {
+function finalizeRouteError(app, context, error, sign, route) {
 	const finalize = app["~finalizeError"];
 	if (!finalize) throw error;
-	return finalize(context, error, sign);
+	return finalize(context, error, sign, false, route);
 }
+const finalizeRouteErrorOf = (route) => route?.error?.length || route?.mapResponse?.length ? (app, context, error, sign) => finalizeRouteError(app, context, error, sign, route) : finalizeRouteError;
 function registerDeriveDisposable(context, value, scan = context) {
 	if (!require_utils.isDisposable(value)) return;
 	if (require_utils.isSingleton(value)) return;
@@ -95,6 +95,7 @@ const hasAsync = (fns) => fns.some((fn) => require_compile_utils.isAsyncFunction
 exports.drainDisposables = drainDisposables;
 exports.emptyResponse = emptyResponse;
 exports.finalizeRouteError = finalizeRouteError;
+exports.finalizeRouteErrorOf = finalizeRouteErrorOf;
 exports.forwardError = forwardError;
 exports.forwardErrorOf = forwardErrorOf;
 exports.getNotFound = getNotFound;