elysia 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/compile/handler/params.js

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../../utils.js');
-const require_universal_is_production = require('../../universal/is-production.js');
 const require_error = require('../../error.js');
 const require_adapter_utils = require('../../adapter/utils.js');
 const require_parse_query = require('../../parse-query.js');
 const require_cookie_utils = require('../../cookie/utils.js');
 const require_handler_utils = require('../../handler/utils.js');
+const require_handler_error = require('../../handler/error.js');
 const require_compile_handler_utils = require('./utils.js');
 
 //#region src/compile/handler/params.ts
@@ -29,10 +29,8 @@ const handlerParams = () => _handlerParams ??= {
 	pe: () => require_error.ParseError,
 	es: () => require_error.ElysiaStatus,
 	rdc: () => require_compile_handler_utils.replaceDeriveContext,
-	ise: () => require_error.internalServerErrorResponse,
 	emp: () => require_handler_utils.emptyResponse,
 	ea: () => require_compile_handler_utils.armEntryAbort,
-	isprod: () => require_universal_is_production.isProduction,
 	verr: () => require_error.ValidationError,
 	tee: () => require_adapter_utils.tee,
 	msh: () => require_adapter_utils.materializeSetHeaders,
@@ -47,6 +45,8 @@ const handlerParams = () => _handlerParams ??= {
 	va: (c) => c.vali,
 	fe: () => require_handler_utils.forwardError,
 	fre: () => require_handler_utils.finalizeRouteError,
+	fbr: () => require_handler_error.fallbackResponse,
+	aet: () => require_handler_error.adoptErrorType,
 	rt: (c) => c.root,
 	ho: (c) => c.hook,
 	tf: (c) => c.hook.transform,

package/dist/compile/handler/params.mjs

@@ -1,10 +1,10 @@
 import { requestId } from "../../utils.mjs";
-import { isProduction } from "../../universal/is-production.mjs";
-import { ElysiaStatus, ParseError, ValidationError, internalServerErrorResponse } from "../../error.mjs";
+import { ElysiaStatus, ParseError, ValidationError } from "../../error.mjs";
 import { materializeSetHeaders, normalizeContentType, tee } from "../../adapter/utils.mjs";
 import { parseQueryFromURL } from "../../parse-query.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
 import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
+import { adoptErrorType, fallbackResponse } from "../../handler/error.mjs";
 import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
 
 //#region src/compile/handler/params.ts
@@ -28,10 +28,8 @@ const handlerParams = () => _handlerParams ??= {
 	pe: () => ParseError,
 	es: () => ElysiaStatus,
 	rdc: () => replaceDeriveContext,
-	ise: () => internalServerErrorResponse,
 	emp: () => emptyResponse,
 	ea: () => armEntryAbort,
-	isprod: () => isProduction,
 	verr: () => ValidationError,
 	tee: () => tee,
 	msh: () => materializeSetHeaders,
@@ -46,6 +44,8 @@ const handlerParams = () => _handlerParams ??= {
 	va: (c) => c.vali,
 	fe: () => forwardError,
 	fre: () => finalizeRouteError,
+	fbr: () => fallbackResponse,
+	aet: () => adoptErrorType,
 	rt: (c) => c.root,
 	ho: (c) => c.hook,
 	tf: (c) => c.hook.transform,

package/dist/compile/handler/utils.d.ts

@@ -1,5 +1,5 @@
-import { AfterResponseHandler, AppHook, ErrorHandler, MaybeArray, TransformHandler } from "../../types.js";
 import { CompactBeforeHandlePrefix, DeriveEntry } from "../../utils.js";
+import { AfterResponseHandler, AppHook, ErrorHandler, MaybeArray, TransformHandler } from "../../types.js";
 import { Context } from "../../context.js";
 import { emptyResponse } from "../../handler/utils.js";
 

package/dist/compile/handler/utils.js

@@ -5,6 +5,7 @@ const require_adapter_skip_clone = require('../../adapter/skip-clone.js');
 const require_error = require('../../error.js');
 const require_compile_utils = require('../utils.js');
 const require_handler_utils = require('../../handler/utils.js');
+const require_handler_error = require('../../handler/error.js');
 const require_adapter_origin = require('../../adapter/origin.js');
 const require_compile_lexer = require('../lexer.js');
 
@@ -402,11 +403,13 @@ const mapAfterHandle = (_hooks, isAsync, report, abortGuard) => mapChainHook(toA
 const mapMapResponse = (_hooks, isAsync, report, abortGuard) => mapChainHook(toArray(_hooks), "mr", isAsync, report, abortGuard);
 const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const t = trace(report, fn);
-	return `try{` + t.begin + `${Await(fn)}ar${at(i)}(c)\n` + t.end() + `}catch(_e){` + t.end("_e") + `}\n`;
+	const call = require_compile_utils.isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(_ar instanceof Promise)await _ar\n`;
+	return `try{` + t.begin + call + t.end() + `}catch(_e){` + t.end("_e") + `}\n`;
 });
 const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, isAsync]) => {
 	link(mapResponse, "rm");
-	return `_r=${Await(fn)}er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r") + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(_r,c.set,c.request,true))\n}\n`;
+	link(require_handler_error.adoptErrorType, "aet");
+	return `_r=${Await(fn)}er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r") + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
 });
 function map(map) {
 	return function(event, rest, abortGuard) {

package/dist/compile/handler/utils.mjs

@@ -4,6 +4,7 @@ import { skipClone } from "../../adapter/skip-clone.mjs";
 import { ElysiaStatus } from "../../error.mjs";
 import { isAsyncFunction } from "../utils.mjs";
 import { emptyResponse } from "../../handler/utils.mjs";
+import { adoptErrorType } from "../../handler/error.mjs";
 import { origin } from "../../adapter/origin.mjs";
 import { isIdentChar, isSpace, skipString } from "../lexer.mjs";
 
@@ -401,11 +402,13 @@ const mapAfterHandle = (_hooks, isAsync, report, abortGuard) => mapChainHook(toA
 const mapMapResponse = (_hooks, isAsync, report, abortGuard) => mapChainHook(toArray(_hooks), "mr", isAsync, report, abortGuard);
 const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const t = trace(report, fn);
-	return `try{` + t.begin + `${Await(fn)}ar${at(i)}(c)\n` + t.end() + `}catch(_e){` + t.end("_e") + `}\n`;
+	const call = isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(_ar instanceof Promise)await _ar\n`;
+	return `try{` + t.begin + call + t.end() + `}catch(_e){` + t.end("_e") + `}\n`;
 });
 const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, isAsync]) => {
 	link(mapResponse, "rm");
-	return `_r=${Await(fn)}er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r") + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(_r,c.set,c.request,true))\n}\n`;
+	link(adoptErrorType, "aet");
+	return `_r=${Await(fn)}er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r") + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
 });
 function map(map) {
 	return function(event, rest, abortGuard) {

package/dist/context.d.ts

@@ -1,10 +1,10 @@
 import { BaseCookie } from "./cookie/types.js";
 import { Cookie } from "./cookie/cookie.js";
 import { StatusMap } from "./constants.js";
-import { SelectiveStatus, status } from "./error.js";
 import { Server } from "./universal/server.js";
-import { AfterResponseHandler, DefaultSingleton, HTTPHeaders, InputSchema, MaybePromise, Prettify, ResolvePath, RouteSchema, SingletonBase } from "./types.js";
 import { redirect } from "./utils.js";
+import { AfterResponseHandler, DefaultSingleton, HTTPHeaders, InputSchema, MaybePromise, Prettify, ResolvePath, RouteSchema, SingletonBase } from "./types.js";
+import { SelectiveStatus, status } from "./error.js";
 import { AnyElysia } from "./base.js";
 
 //#region src/context.d.ts

package/dist/cookie/cookie.js

@@ -90,6 +90,7 @@ var Cookie = class {
 		return typeof this.value === "object" ? JSON.stringify(this.value) : this.value?.toString() ?? "";
 	}
 };
+Object.defineProperty(Cookie, "name", { value: "Cookie" });
 for (const key of FORWARDED_KEYS) Object.defineProperty(Cookie.prototype, key, {
 	get() {
 		return this.cookie[key];

package/dist/cookie/cookie.mjs

@@ -89,6 +89,7 @@ var Cookie = class {
 		return typeof this.value === "object" ? JSON.stringify(this.value) : this.value?.toString() ?? "";
 	}
 };
+Object.defineProperty(Cookie, "name", { value: "Cookie" });
 for (const key of FORWARDED_KEYS) Object.defineProperty(Cookie.prototype, key, {
 	get() {
 		return this.cookie[key];

package/dist/error.d.ts

@@ -1,5 +1,6 @@
 import { StatusMap, StatusMapBack } from "./constants.js";
 import { isProduction } from "./universal/is-production.js";
+import { MaybePromise } from "./types.js";
 
 //#region src/error.d.ts
 declare class ElysiaError<Status extends number = number, Response extends string = string> extends Error {
@@ -193,13 +194,14 @@ type NumericStatus<Code extends number | keyof StatusMap> = Code extends keyof S
 type ProblemStatus<P> = P extends {
   status: infer S extends number | keyof StatusMap;
 } ? NumericStatus<S> : 500;
-type ProblemResponseBody<Status extends number, P> = {
+type ProblemResponseBody<Status extends number, P> = Omit<{
   type: string;
   title: string;
-  status: Status;
   detail?: string;
   instance?: string;
-} & Omit<P, keyof Problem>;
+}, keyof P> & Omit<P, 'status'> & {
+  status: Status;
+};
 declare function problemBody(p: Problem): Record<string, unknown> & {
   status: number;
 };
@@ -217,7 +219,9 @@ declare function internalServerErrorResponse(error: any): Response;
  *
  * @see https://www.rfc-editor.org/info/rfc9457
  */
-declare function problem<const Code extends number | keyof StatusMap, const P extends Record<string, unknown> = {}>(status: Code, detail?: P & Omit<Problem<Code>, 'status'>): ElysiaStatus<NumericStatus<Code>, ProblemResponseBody<NumericStatus<Code>, P>>;
+declare function problem<const Code extends number | keyof StatusMap, const P extends Record<string, unknown> & {
+  status?: never;
+} = {}>(status: Code, detail?: P & Omit<Problem<Code>, 'status'>): ElysiaStatus<NumericStatus<Code>, ProblemResponseBody<NumericStatus<Code>, P>>;
 /**
  * RFC 9457 Problem Details function
  *
@@ -231,5 +235,134 @@ declare function problem<const Code extends number | keyof StatusMap, const P ex
 declare function problem<const P extends Problem>(detail: P): ElysiaStatus<ProblemStatus<P>, ProblemResponseBody<ProblemStatus<P>, P>>;
 type CheckExcessProps<T, U> = 0 extends 1 & T ? T : U extends U ? Exclude<keyof T, keyof U> extends never ? T : { [K in keyof U]: U[K] } & { [K in Exclude<keyof T, keyof U>]: never } : never;
 type SelectiveStatus<in out Res> = <const Code extends keyof Res | StatusMapBack[Extract<keyof StatusMapBack, keyof Res>], T extends (Code extends keyof Res ? Res[Code] : Code extends keyof StatusMap ? Res[StatusMap[Code]] : never)>(code: Code, response: CheckExcessProps<T, Code extends keyof Res ? Res[Code] : Code extends keyof StatusMap ? Res[StatusMap[Code]] : never>) => ElysiaStatus<Code, T>;
+/**
+ * Class returned by {@link HTTPError.id}
+ */
+type TaggedHTTPError<Type extends string, Annotation = {}> = {
+  new (message?: string, options?: ErrorOptions): HTTPError<Type> & {
+    type: Type;
+  } & Annotation;
+  prototype: HTTPError<Type>;
+};
+/**
+ * Self-describing HTTP error
+ *
+ * Annotate `status`, `headers` and `value` on the subclass and Elysia maps
+ * the instance to a response on its own, no `.error(Class, handler)` needed
+ *
+ * Everything an owned `HTTPError` serves is an RFC 9457 problem document:
+ * `type` is the problem type carried on the wire, an annotated object body
+ * merges into the envelope, and any other body (or the error message, when
+ * there is none) becomes `detail`
+ *
+ * - `detail()` - the common case. Whatever it returns becomes the `detail`
+ *   member of the problem document, verbatim, objects included. The envelope
+ *   still carries `type`, `status` and an auto-filled `title`
+ * - `value()` - the escape hatch. Whatever it returns replaces the *whole*
+ *   response: no envelope, no `application/problem+json`. The annotated
+ *   `status` and `headers` still apply, only the content is yours
+ *
+ * `value` wins over `detail`, `detail` over the error message. A knob
+ * returning `undefined` falls through to the next one.
+ *
+ * @example
+ * ```ts
+ * class OutOfCredit extends HTTPError<'OUT_OF_CREDIT'> {
+ * 	type = 'OUT_OF_CREDIT' as const
+ * 	override readonly status = 402
+ *
+ * 	detail() {
+ * 		return { balance: 0, currency: 'usd' }
+ * 	}
+ * }
+ * // → { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
+ * //     detail: { balance: 0, currency: 'usd' } }
+ *
+ * class Overdrawn extends HTTPError<'OVERDRAWN'> {
+ * 	type = 'OVERDRAWN' as const
+ * 	override readonly status = 402
+ *
+ * 	async detail() {
+ * 		return await describeBalance()
+ * 	}
+ * }
+ *
+ * class Legacy extends HTTPError<'LEGACY'> {
+ * 	type = 'LEGACY' as const
+ * 	override readonly status = 402
+ *
+ * 	// full control, served as-is
+ * 	value() {
+ * 		return { code: 'OUT_OF_CREDIT', ok: false }
+ * 	}
+ * }
+ * ```
+ *
+ * @see https://www.rfc-editor.org/info/rfc9457
+ * @since 2.0.0
+ */
+declare abstract class HTTPError<const in out T extends string = string> extends Error {
+  /**
+   * RFC 9457 problem type served in the `type` member, a URI or a slug.
+   * Doubles as the tag that discriminates one error class from another
+   */
+  abstract type: T;
+  /**
+   * HTTP status served when the error reaches the error pipeline,
+   * as a number or a status name (`'Payment Required'`)
+   */
+  readonly status?: number | keyof StatusMap;
+  /** Headers merged into `set.headers` when the error is served */
+  readonly headers?: Record<string, string>;
+  /**
+   * Return a value to serve as the whole response
+   *
+   * Supports `status()`/`problem()` for status-based Eden response
+   */
+  value?(): MaybePromise<unknown>;
+  /**
+   * Return the `detail` member of the RFC 9457 problem document,
+   * similar to `problem()`
+   *
+   * Use `value()` to override the entire response
+   */
+  detail?(): MaybePromise<unknown>;
+  /**
+   * Create a concrete `HTTPError` subclass carrying `type`
+   *
+   * `type` carries no status annotation, annotate `status` in the subclass
+   * body as a number or a status name
+   *
+   * @example
+   * ```ts
+   * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {
+   *     headers = {
+   *         'x-powered-by': 'Elysia'
+   *     }
+   * }
+   * ```
+   */
+  static id<const Type extends string>(type: Type): TaggedHTTPError<Type>;
+  /**
+   * Create a concrete `HTTPError` subclass carrying `type`, annotated with
+   * `status` as a number or a status name
+   *
+   * Annotate what is served with `detail()` (problem `detail` member) or
+   * `value()` (whole-response override), either of which may be `async`
+   *
+   * @example
+   * ```ts
+   * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {}
+   * class Denied extends HTTPError.id('https://example.com/denied', 'Payment Required') {
+   *     async detail() {
+   *         return await describeBalance()
+   *     }
+   * }
+   * ```
+   */
+  static id<const Type extends string, const S extends number | keyof StatusMap>(type: Type, status: S): TaggedHTTPError<Type, {
+    readonly status: S extends keyof StatusMap ? StatusMap[S] : S;
+  }>;
+}
 //#endregion
-export { ElysiaError, ElysiaStatus, InternalServerError, NotFound, PROBLEM_JSON, ParseError, Problem, SelectiveStatus, ValidationError, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, status, subValueAt, validationDetail };
+export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, PROBLEM_JSON, ParseError, Problem, ProblemResponseBody, SelectiveStatus, TaggedHTTPError, ValidationError, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, status, subValueAt, validationDetail };

package/dist/error.js

@@ -437,6 +437,7 @@ var ElysiaStatus = class {
 		return this.code;
 	}
 };
+Object.defineProperty(ElysiaStatus, "name", { value: "ElysiaStatus" });
 const status = (code, response) => new ElysiaStatus(code, response);
 const PROBLEM_JSON = "application/problem+json";
 function problemBody(p) {
@@ -507,10 +508,82 @@ function problem(statusOrDetail, detail) {
 	};
 	return new ElysiaStatus(body.status ?? 500, problemBody(body), { "content-type": PROBLEM_JSON });
 }
+/**
+* Self-describing HTTP error
+*
+* Annotate `status`, `headers` and `value` on the subclass and Elysia maps
+* the instance to a response on its own, no `.error(Class, handler)` needed
+*
+* Everything an owned `HTTPError` serves is an RFC 9457 problem document:
+* `type` is the problem type carried on the wire, an annotated object body
+* merges into the envelope, and any other body (or the error message, when
+* there is none) becomes `detail`
+*
+* - `detail()` - the common case. Whatever it returns becomes the `detail`
+*   member of the problem document, verbatim, objects included. The envelope
+*   still carries `type`, `status` and an auto-filled `title`
+* - `value()` - the escape hatch. Whatever it returns replaces the *whole*
+*   response: no envelope, no `application/problem+json`. The annotated
+*   `status` and `headers` still apply, only the content is yours
+*
+* `value` wins over `detail`, `detail` over the error message. A knob
+* returning `undefined` falls through to the next one.
+*
+* @example
+* ```ts
+* class OutOfCredit extends HTTPError<'OUT_OF_CREDIT'> {
+* 	type = 'OUT_OF_CREDIT' as const
+* 	override readonly status = 402
+*
+* 	detail() {
+* 		return { balance: 0, currency: 'usd' }
+* 	}
+* }
+* // → { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
+* //     detail: { balance: 0, currency: 'usd' } }
+*
+* class Overdrawn extends HTTPError<'OVERDRAWN'> {
+* 	type = 'OVERDRAWN' as const
+* 	override readonly status = 402
+*
+* 	async detail() {
+* 		return await describeBalance()
+* 	}
+* }
+*
+* class Legacy extends HTTPError<'LEGACY'> {
+* 	type = 'LEGACY' as const
+* 	override readonly status = 402
+*
+* 	// full control, served as-is
+* 	value() {
+* 		return { code: 'OUT_OF_CREDIT', ok: false }
+* 	}
+* }
+* ```
+*
+* @see https://www.rfc-editor.org/info/rfc9457
+* @since 2.0.0
+*/
+var HTTPError = class HTTPError extends Error {
+	static id(type, status) {
+		const Tagged = class extends HTTPError {};
+		Tagged.prototype.type = type;
+		Tagged.prototype.name = type;
+		Object.defineProperty(Tagged, "name", {
+			value: type,
+			configurable: true
+		});
+		const resolved = typeof status === "string" ? require_constants.StatusMap[status] : status;
+		if (typeof resolved === "number") Tagged.prototype.status = resolved;
+		return Tagged;
+	}
+};
 
 //#endregion
 exports.ElysiaError = ElysiaError;
 exports.ElysiaStatus = ElysiaStatus;
+exports.HTTPError = HTTPError;
 exports.InternalServerError = InternalServerError;
 exports.NotFound = NotFound;
 exports.PROBLEM_JSON = PROBLEM_JSON;

package/dist/error.mjs

@@ -436,6 +436,7 @@ var ElysiaStatus = class {
 		return this.code;
 	}
 };
+Object.defineProperty(ElysiaStatus, "name", { value: "ElysiaStatus" });
 const status = (code, response) => new ElysiaStatus(code, response);
 const PROBLEM_JSON = "application/problem+json";
 function problemBody(p) {
@@ -506,6 +507,77 @@ function problem(statusOrDetail, detail) {
 	};
 	return new ElysiaStatus(body.status ?? 500, problemBody(body), { "content-type": PROBLEM_JSON });
 }
+/**
+* Self-describing HTTP error
+*
+* Annotate `status`, `headers` and `value` on the subclass and Elysia maps
+* the instance to a response on its own, no `.error(Class, handler)` needed
+*
+* Everything an owned `HTTPError` serves is an RFC 9457 problem document:
+* `type` is the problem type carried on the wire, an annotated object body
+* merges into the envelope, and any other body (or the error message, when
+* there is none) becomes `detail`
+*
+* - `detail()` - the common case. Whatever it returns becomes the `detail`
+*   member of the problem document, verbatim, objects included. The envelope
+*   still carries `type`, `status` and an auto-filled `title`
+* - `value()` - the escape hatch. Whatever it returns replaces the *whole*
+*   response: no envelope, no `application/problem+json`. The annotated
+*   `status` and `headers` still apply, only the content is yours
+*
+* `value` wins over `detail`, `detail` over the error message. A knob
+* returning `undefined` falls through to the next one.
+*
+* @example
+* ```ts
+* class OutOfCredit extends HTTPError<'OUT_OF_CREDIT'> {
+* 	type = 'OUT_OF_CREDIT' as const
+* 	override readonly status = 402
+*
+* 	detail() {
+* 		return { balance: 0, currency: 'usd' }
+* 	}
+* }
+* // → { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
+* //     detail: { balance: 0, currency: 'usd' } }
+*
+* class Overdrawn extends HTTPError<'OVERDRAWN'> {
+* 	type = 'OVERDRAWN' as const
+* 	override readonly status = 402
+*
+* 	async detail() {
+* 		return await describeBalance()
+* 	}
+* }
+*
+* class Legacy extends HTTPError<'LEGACY'> {
+* 	type = 'LEGACY' as const
+* 	override readonly status = 402
+*
+* 	// full control, served as-is
+* 	value() {
+* 		return { code: 'OUT_OF_CREDIT', ok: false }
+* 	}
+* }
+* ```
+*
+* @see https://www.rfc-editor.org/info/rfc9457
+* @since 2.0.0
+*/
+var HTTPError = class HTTPError extends Error {
+	static id(type, status) {
+		const Tagged = class extends HTTPError {};
+		Tagged.prototype.type = type;
+		Tagged.prototype.name = type;
+		Object.defineProperty(Tagged, "name", {
+			value: type,
+			configurable: true
+		});
+		const resolved = typeof status === "string" ? StatusMap[status] : status;
+		if (typeof resolved === "number") Tagged.prototype.status = resolved;
+		return Tagged;
+	}
+};
 
 //#endregion
-export { ElysiaError, ElysiaStatus, InternalServerError, NotFound, PROBLEM_JSON, ParseError, ValidationError, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, status, subValueAt, validationDetail };
+export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, PROBLEM_JSON, ParseError, ValidationError, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, status, subValueAt, validationDetail };

package/dist/handler/error.d.ts

@@ -2,6 +2,25 @@ import { AppHook } from "../types.js";
 import { Context } from "../context.js";
 
 //#region src/handler/error.d.ts
+/**
+ * Adopt the intercepted error's `type` into a problem the hook produced
+ * without one.
+ *
+ * `'about:blank'` is RFC 9457's "unspecified" default, so it's the only value
+ * worth replacing — an explicit type the handler set always wins.
+ *
+ * The result is copied rather than mutated: `.error(Class, value)` wraps a
+ * non-function into `() => value`, so the very same `ElysiaStatus` is replayed
+ * on every request and an in-place write would leak across requests
+ */
+declare function adoptErrorType(result: any, error: any): any;
+/**
+ * Response served once every error hook has declined the error.
+ *
+ * Exported for the JIT: a route with error hooks emits its own catch block,
+ * which must land on *this* function rather than re-implementing it
+ */
+declare function fallbackResponse(context: Context, error: any, mapResponse: (response: unknown, set: Context['set'], context?: Context) => unknown, defaultError?: Response): unknown;
 declare function createErrorHandler(onErrors: AppHook['error'] | undefined, mapResponse: (response: unknown, set: Context['set'], ...any: unknown[]) => unknown, defaultError?: Response, allowUnsafe?: boolean): (context: Context, error: Error) => unknown;
 //#endregion
-export { createErrorHandler };
+export { adoptErrorType, createErrorHandler, fallbackResponse };