elysia 2.0.0-beta.30 → 2.0.0-beta.32

package/dist/base.js

@@ -661,7 +661,8 @@ var Elysia = class Elysia {
 				throw err;
 			}));
 		}
-		return this;
+		if (!result || result === this) return this;
+		return this.use(result);
 	}
 	#use(app) {
 		let addedByThisCall;
@@ -969,7 +970,7 @@ var Elysia = class Elysia {
 			this.fetchFn = void 0;
 			this.#routerBuilt = false;
 			require_context.clearContextCache(this);
-			try {
+			if (this["~map"]) try {
 				this.#buildRouter(false);
 			} catch (error) {
 				this.compiled = previousCompiled;
@@ -1498,7 +1499,7 @@ var Elysia = class Elysia {
 		let eager = false;
 		if (length) {
 			const programId = this["~programId"];
-			if (!require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint())) require_compile_aot.Compiled.assertUncontested(programId);
+			require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint(), this["~config"]?.name || "");
 			markDuplicates = require_compile_aot.Compiled.hasProgram(programId) || precompile !== true && require_universal_is_production.isProduction() && !require_compile_aot.Capture.isAotBuildEnv();
 			if (hasTypeBoxSchema) try {
 				require_type_bridge.warmTypebox();

package/dist/base.mjs

@@ -659,7 +659,8 @@ var Elysia = class Elysia {
 				throw err;
 			}));
 		}
-		return this;
+		if (!result || result === this) return this;
+		return this.use(result);
 	}
 	#use(app) {
 		let addedByThisCall;
@@ -967,7 +968,7 @@ var Elysia = class Elysia {
 			this.fetchFn = void 0;
 			this.#routerBuilt = false;
 			clearContextCache(this);
-			try {
+			if (this["~map"]) try {
 				this.#buildRouter(false);
 			} catch (error) {
 				this.compiled = previousCompiled;
@@ -1496,7 +1497,7 @@ var Elysia = class Elysia {
 		let eager = false;
 		if (length) {
 			const programId = this["~programId"];
-			if (!Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint())) Compiled.assertUncontested(programId);
+			Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint(), this["~config"]?.name || "");
 			markDuplicates = Compiled.hasProgram(programId) || precompile !== true && isProduction() && !Capture.isAotBuildEnv();
 			if (hasTypeBoxSchema) try {
 				warmTypebox();

package/dist/compile/aot.d.ts

@@ -89,8 +89,8 @@ interface HandlerManifest {
   };
 }
 interface CompiledSnapshot {
-  registered: CompiledProgramRegistration | undefined;
-  claimed: WeakRef<ProgramId> | undefined;
+  registered: Record<string, CompiledProgramRegistration | undefined> | undefined;
+  claimed: Record<string, WeakRef<ProgramId> | undefined> | undefined;
   programs: WeakMap<ProgramId, CompiledProgram>;
 }
 interface CompiledProgramRegistration {
@@ -129,9 +129,8 @@ declare function reconstruct(): ReconstructImpl;
 declare const aotDriftMessage: (method: string, path: string) => string;
 declare function warnAotDrift(method: string, path: string): void;
 declare abstract class Compiled {
-  static register(manifest: CompiledProgramRegistration): void;
-  static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
-  static assertUncontested(id: ProgramId): void;
+  static register(manifest: CompiledProgramRegistration, key?: string): void;
+  static claim(id: ProgramId, fingerprint: AotFingerprint, key?: string): boolean;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
   static hasProgram(id: ProgramId | undefined): boolean;

package/dist/compile/aot.js

@@ -51,26 +51,25 @@ let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 var Compiled = class {
-	static register(manifest) {
-		registered = manifest;
-		claimed = void 0;
+	static register(manifest, key = "") {
+		(registered ??= require_utils.nullObject())[key] = manifest;
+		claimed ??= require_utils.nullObject();
 	}
-	static claim(id, fingerprint) {
-		if (!registered || claimed) return false;
-		const manifest = registered;
+	static claim(id, fingerprint, key = "") {
+		const manifest = registered?.[key];
+		if (!manifest) {
+			if (claimed && claimed[key]?.deref() !== id && !isAotBuildEnv()) throw new Error(`[elysia-aot] App "${key}" has no AOT manifest. Name and export it, .mount() ones too`);
+			return false;
+		}
 		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
-		claimed = new WeakRef(id);
-		registered = void 0;
+		claimed[key] = new WeakRef(id);
+		registered[key] = void 0;
 		programs.set(id, {
 			...manifest,
 			builtGroups: /* @__PURE__ */ new Set()
 		});
 		return true;
 	}
-	static assertUncontested(id) {
-		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
-		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
-	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
 	}

package/dist/compile/aot.mjs

@@ -51,26 +51,25 @@ let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 var Compiled = class {
-	static register(manifest) {
-		registered = manifest;
-		claimed = void 0;
+	static register(manifest, key = "") {
+		(registered ??= nullObject())[key] = manifest;
+		claimed ??= nullObject();
 	}
-	static claim(id, fingerprint) {
-		if (!registered || claimed) return false;
-		const manifest = registered;
+	static claim(id, fingerprint, key = "") {
+		const manifest = registered?.[key];
+		if (!manifest) {
+			if (claimed && claimed[key]?.deref() !== id && !isAotBuildEnv()) throw new Error(`[elysia-aot] App "${key}" has no AOT manifest. Name and export it, .mount() ones too`);
+			return false;
+		}
 		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
-		claimed = new WeakRef(id);
-		registered = void 0;
+		claimed[key] = new WeakRef(id);
+		registered[key] = void 0;
 		programs.set(id, {
 			...manifest,
 			builtGroups: /* @__PURE__ */ new Set()
 		});
 		return true;
 	}
-	static assertUncontested(id) {
-		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
-		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
-	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
 	}

package/dist/compile/handler/jit.js

@@ -414,7 +414,7 @@ function compileHandlerJit(options, tailPass) {
 					link(hook.beforeHandle, "bf");
 					const deriveEntries = hook["~deriveEntries"];
 					const chainGuard = abortChainGuard();
-					const mapped = require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries, link, asyncMode, buildReport("beforeHandle"), chainGuard, arm);
+					const mapped = require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries, link, asyncMode, buildReport("beforeHandle"), chainGuard, arm, errorClasses);
 					code += beforeHandlePrefix ? `if(${chainGuard ? `!${chainGuard}&&` : ""}_r===undefined){\n${mapped}}\n` : mapped;
 				}
 			}
@@ -463,7 +463,7 @@ function compileHandlerJit(options, tailPass) {
 					code += require_compile_handler_utils.mapChainHook(hook.afterHandle, "af", asyncMode, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
-				if (hasAfterHandle) code += abortCheck();
+				if (hasAfterHandle) code += abortCheck() + plain(rethrow("_r"));
 			}
 			if (hasMapResponse || hasTrace) {
 				const mrLen = hook?.mapResponse?.length ?? 0;
@@ -531,15 +531,17 @@ function compileHandlerJit(options, tailPass) {
 				asyncMode.r = false;
 				asyncMode.e = true;
 			}
+			const declined = endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule);
 			body += errorHead + `let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapError(hook.error, [
 				map,
 				link,
 				responseMap,
-				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule),
+				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + declined,
 				signPrefix,
 				asyncMode,
-				arm
-			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode)) + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule) + `return _efb(e,c)\n`;
+				arm,
+				declined
+			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode)) + declined + `return _efb(e,c)\n`;
 		} else body += endTrace("error") + freThenSchedule("e");
 		const hookThrew = `catch(_ee){${freThenSchedule("_ee").trimEnd()}}}\n`;
 		const syncFirst = typeof asyncMode === "object" && !asyncMode.async;

package/dist/compile/handler/jit.mjs

@@ -414,7 +414,7 @@ function compileHandlerJit(options, tailPass) {
 					link(hook.beforeHandle, "bf");
 					const deriveEntries = hook["~deriveEntries"];
 					const chainGuard = abortChainGuard();
-					const mapped = mapBeforeHandle(hook.beforeHandle, deriveEntries, link, asyncMode, buildReport("beforeHandle"), chainGuard, arm);
+					const mapped = mapBeforeHandle(hook.beforeHandle, deriveEntries, link, asyncMode, buildReport("beforeHandle"), chainGuard, arm, errorClasses);
 					code += beforeHandlePrefix ? `if(${chainGuard ? `!${chainGuard}&&` : ""}_r===undefined){\n${mapped}}\n` : mapped;
 				}
 			}
@@ -463,7 +463,7 @@ function compileHandlerJit(options, tailPass) {
 					code += mapChainHook(hook.afterHandle, "af", asyncMode, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
-				if (hasAfterHandle) code += abortCheck();
+				if (hasAfterHandle) code += abortCheck() + plain(rethrow("_r"));
 			}
 			if (hasMapResponse || hasTrace) {
 				const mrLen = hook?.mapResponse?.length ?? 0;
@@ -531,15 +531,17 @@ function compileHandlerJit(options, tailPass) {
 				asyncMode.r = false;
 				asyncMode.e = true;
 			}
+			const declined = endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule);
 			body += errorHead + `let _r${hasMapResponse ? ",tmp" : ""}\n` + mapError(hook.error, [
 				map,
 				link,
 				responseMap,
-				(hasMapResponse ? `c.responseValue=_r\n` + mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule),
+				(hasMapResponse ? `c.responseValue=_r\n` + mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + declined,
 				signPrefix,
 				asyncMode,
-				arm
-			], abortChainGuard(), asyncTail(asyncMode)) + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule) + `return _efb(e,c)\n`;
+				arm,
+				declined
+			], abortChainGuard(), asyncTail(asyncMode)) + declined + `return _efb(e,c)\n`;
 		} else body += endTrace("error") + freThenSchedule("e");
 		const hookThrew = `catch(_ee){${freThenSchedule("_ee").trimEnd()}}}\n`;
 		const syncFirst = typeof asyncMode === "object" && !asyncMode.async;

package/dist/compile/handler/params.js

@@ -54,6 +54,7 @@ const handlerParams = () => _handlerParams ??= {
 		const classes = require_handler_utils.returnedErrorClasses(c.hook);
 		return classes ? require_handler_utils.forwardErrorOf(classes) : require_handler_utils.forwardError;
 	},
+	ec: (c) => require_handler_utils.returnedErrorClasses(c.hook),
 	fre: (c) => require_handler_utils.finalizeRouteErrorOf(c.hook),
 	fbr: () => require_handler_error.fallbackResponse,
 	aet: () => require_handler_error.adoptErrorType,

package/dist/compile/handler/params.mjs

@@ -54,6 +54,7 @@ const handlerParams = () => _handlerParams ??= {
 		const classes = returnedErrorClasses(c.hook);
 		return classes ? forwardErrorOf(classes) : forwardError;
 	},
+	ec: (c) => returnedErrorClasses(c.hook),
 	fre: (c) => finalizeRouteErrorOf(c.hook),
 	fbr: () => fallbackResponse,
 	aet: () => adoptErrorType,

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

@@ -30,7 +30,7 @@ declare function deriveModes(hooks: Function[], entries?: readonly DeriveEntry[]
  * their own entries joined already do
  */
 declare function joinDeriveEntries(parts: readonly (Partial<AppHook> | undefined)[]): DeriveEntry[] | undefined;
-declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, mode: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string): string;
+declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, mode: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string, errorClasses?: Function[]): string;
 type BeforeHandleContext = {
   request: Request;
   '~sig'?: AbortSignal;
@@ -39,7 +39,7 @@ declare function runBeforeHandlePrefix(prefix: CompactBeforeHandlePrefix, contex
 declare function runBeforeHandlePrefixAsync(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): Promise<any>;
 declare function mapChainHook(_hooks: Function | Function[], prefix: string, mode: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string): string;
 declare const mapAfterResponse: (event: MaybeArray<AfterResponseHandler<any, any, undefined, "local">>, rest?: [report?: TraceReporter | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
-declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, mode: AsyncMode, arm?: string | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
+declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, mode: AsyncMode, arm: string | undefined, declined: string] | undefined, abortGuard?: string, tail?: TailMode) => string;
 interface QueryWalkState {
   array: Record<string, 1> | undefined;
   object: Record<string, 1> | undefined;

package/dist/compile/handler/utils.js

@@ -203,12 +203,13 @@ function joinDeriveEntries(parts) {
 	}
 	if (at) return require_utils.occurrenceDeriveEntries(hooks, at);
 }
-function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm) {
+function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm, errorClasses) {
 	const hooks = toArray(_hooks);
 	const modes = deriveModes(hooks, derive);
 	const tail = asyncTail(mode);
 	let code = "";
 	let needsEs = false;
+	const early = "if(tmp instanceof es||tmp instanceof Error" + (errorClasses ? "||ec.some((C)=>tmp instanceof C)" : "") + ")_r=tmp\n";
 	for (let i = 0; i < hooks.length; i++) {
 		const fn = hooks[i];
 		const guard = i > 0 ? `${abortGuard ? `!${abortGuard}&&` : ""}_r===undefined` : void 0;
@@ -222,18 +223,20 @@ function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm) {
 			link(require_handler_utils.registerDeriveDisposable, "dsp");
 			if (modes[i]) {
 				link(replaceDeriveContext, "rdc");
-				code += "if(tmp instanceof es)_r=tmp\nelse if(tmp){if(typeof tmp==='object'||typeof tmp==='function'){const _pc=c;c=rdc(c,tmp);for(const _k of Reflect.ownKeys(tmp))dsp(c,c[_k],_pc)}tmp=undefined}\n";
+				code += early + "else if(tmp){if(typeof tmp==='object'||typeof tmp==='function'){const _pc=c;c=rdc(c,tmp);for(const _k of Reflect.ownKeys(tmp))dsp(c,c[_k],_pc)}tmp=undefined}\n";
 			} else {
 				const keys = extractDeriveKeys(fn);
 				const merge = !!keys && !!keys.length && !keys.includes("__proto__") ? keys.map((k) => `_v=tmp[${JSON.stringify(k)}];dsp(c,_v);c[${JSON.stringify(k)}]=_v`).join(";") : "if(Object.hasOwn(tmp,'__proto__')){for(const _k of Object.keys(tmp))dsp(c,tmp[_k]);Object.defineProperties(c,Object.getOwnPropertyDescriptors(tmp))}else{_v=Object.assign({},tmp);for(const _k of Reflect.ownKeys(_v)){dsp(c,_v[_k]);c[_k]=_v[_k]}}";
-				code += `if(tmp instanceof es)_r=tmp
-else if(tmp){${merge};tmp=undefined}\n`;
+				code += early + `else if(tmp){${merge};tmp=undefined}\n`;
 			}
 		} else code += "if(tmp!==undefined)_r=tmp\n";
 		code += t.end("tmp");
 		if (tail || guard) code += "}\n";
 	}
-	if (needsEs) link(require_error.ElysiaStatus, "es");
+	if (needsEs) {
+		link(require_error.ElysiaStatus, "es");
+		if (errorClasses) link(errorClasses, "ec");
+	}
 	return code;
 }
 const compactBeforeHandleChunks = (prefix) => {
@@ -294,11 +297,11 @@ const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const call = require_compile_utils.isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(typeof _ar?.then==='function')await _ar\n`;
 	return `try{${t.begin}${call}${t.end()}}catch(_e){${t.end("_e")}console.error(_e)}\n`;
 });
-const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm]) => {
+const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm, declined]) => {
 	link(mapResponse, "rm");
 	link(require_handler_error.adoptErrorType, "aet");
 	link(require_error.ElysiaStatus, "es");
-	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + "if(_r!==undefined){\nif(_r instanceof es||_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`;
+	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + `if(_r!==undefined){\nif(_r instanceof Error){c.set.status=_r.status||500\n${declined}return _efb(_r,c)}\nif(_r instanceof es||_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, tail) {

package/dist/compile/handler/utils.mjs

@@ -203,12 +203,13 @@ function joinDeriveEntries(parts) {
 	}
 	if (at) return occurrenceDeriveEntries(hooks, at);
 }
-function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm) {
+function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm, errorClasses) {
 	const hooks = toArray(_hooks);
 	const modes = deriveModes(hooks, derive);
 	const tail = asyncTail(mode);
 	let code = "";
 	let needsEs = false;
+	const early = "if(tmp instanceof es||tmp instanceof Error" + (errorClasses ? "||ec.some((C)=>tmp instanceof C)" : "") + ")_r=tmp\n";
 	for (let i = 0; i < hooks.length; i++) {
 		const fn = hooks[i];
 		const guard = i > 0 ? `${abortGuard ? `!${abortGuard}&&` : ""}_r===undefined` : void 0;
@@ -222,18 +223,20 @@ function mapBeforeHandle(_hooks, derive, link, mode, report, abortGuard, arm) {
 			link(registerDeriveDisposable, "dsp");
 			if (modes[i]) {
 				link(replaceDeriveContext, "rdc");
-				code += "if(tmp instanceof es)_r=tmp\nelse if(tmp){if(typeof tmp==='object'||typeof tmp==='function'){const _pc=c;c=rdc(c,tmp);for(const _k of Reflect.ownKeys(tmp))dsp(c,c[_k],_pc)}tmp=undefined}\n";
+				code += early + "else if(tmp){if(typeof tmp==='object'||typeof tmp==='function'){const _pc=c;c=rdc(c,tmp);for(const _k of Reflect.ownKeys(tmp))dsp(c,c[_k],_pc)}tmp=undefined}\n";
 			} else {
 				const keys = extractDeriveKeys(fn);
 				const merge = !!keys && !!keys.length && !keys.includes("__proto__") ? keys.map((k) => `_v=tmp[${JSON.stringify(k)}];dsp(c,_v);c[${JSON.stringify(k)}]=_v`).join(";") : "if(Object.hasOwn(tmp,'__proto__')){for(const _k of Object.keys(tmp))dsp(c,tmp[_k]);Object.defineProperties(c,Object.getOwnPropertyDescriptors(tmp))}else{_v=Object.assign({},tmp);for(const _k of Reflect.ownKeys(_v)){dsp(c,_v[_k]);c[_k]=_v[_k]}}";
-				code += `if(tmp instanceof es)_r=tmp
-else if(tmp){${merge};tmp=undefined}\n`;
+				code += early + `else if(tmp){${merge};tmp=undefined}\n`;
 			}
 		} else code += "if(tmp!==undefined)_r=tmp\n";
 		code += t.end("tmp");
 		if (tail || guard) code += "}\n";
 	}
-	if (needsEs) link(ElysiaStatus, "es");
+	if (needsEs) {
+		link(ElysiaStatus, "es");
+		if (errorClasses) link(errorClasses, "ec");
+	}
 	return code;
 }
 const compactBeforeHandleChunks = (prefix) => {
@@ -294,11 +297,11 @@ const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const call = isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(typeof _ar?.then==='function')await _ar\n`;
 	return `try{${t.begin}${call}${t.end()}}catch(_e){${t.end("_e")}console.error(_e)}\n`;
 });
-const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm]) => {
+const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm, declined]) => {
 	link(mapResponse, "rm");
 	link(adoptErrorType, "aet");
 	link(ElysiaStatus, "es");
-	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + "if(_r!==undefined){\nif(_r instanceof es||_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`;
+	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + `if(_r!==undefined){\nif(_r instanceof Error){c.set.status=_r.status||500\n${declined}return _efb(_r,c)}\nif(_r instanceof es||_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, tail) {

package/dist/error.d.ts

@@ -232,54 +232,36 @@ type TaggedHTTPError<Type extends string, Annotation = {}> = {
 /**
  * Self-describing HTTP error
  *
- * Annotate `status`, `headers` and `value` on the subclass and Elysia maps
- * the instance to a response on its own, no `.onError(Class, handler)` needed
+ * Set `status`, `headers`, `detail`, `extension` and `value` to map to response
  *
- * Everything an owned `HTTPError` serves is an RFC 9457 problem document:
- * `type` is the problem type carried on the wire, and the body (or the error
- * message, when there is none) becomes `detail`, an object nested verbatim
- * and never merged into the envelope
+ * Send RFC 9457 problem document by default that can be overridden by `value()`
  *
- * - `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
+ * - `detail` - add `detail` field to the problem document
+ * - `extension()` - add extension members to the problem document
+ * - `value()` - override the whole response, return `problem()` to keep the shape
  *
- * `value` wins over `detail`, `detail` over the error message. A knob
- * returning `undefined` falls through to the next one.
+ * `value` wins over `detail`, `detail` over an `extension()` string `detail`,
+ * that over message. A `value` returning `undefined` falls
+ * through to the next one. A response that depends on the request belongs in
+ * `.onError(Class, handler)`
  *
  * @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' }
- * 	}
+ * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT') {
+ * 	   readonly status = 402
+ * 	   readonly detail = 'Top up to continue'
  * }
- * // → { 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
+ * class Overdrawn extends Error implements HTTPError {
+ *     readonly type = 'OVERDRAWN'
+ * 	   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 }
- * 	}
+ *     value() {
+ *         return problem(402, {
+ * 	           type: 'OVERDRAWN',
+ * 	            detail: await describeBalance()
+ * 	       })
+ *     }
  * }
  * ```
  *
@@ -328,18 +310,44 @@ declare abstract class HTTPError<const in out T extends string = string> extends
   /** Headers merged into `set.headers` when the error is served */
   readonly headers?: Record<string, string>;
   /**
-   * Return a value to serve as the whole response
+   * Return a value to serve as the whole response, may be `async`
    *
    * Supports `status()`/`problem()` for status-based Eden response
    */
   value?(): MaybePromise<unknown>;
   /**
-   * Return the `detail` member of the RFC 9457 problem document,
-   * similar to `problem()`
+   * `detail` member of the RFC 9457 problem document, served in place of
+   * the error message
    *
-   * Use `value()` to override the entire response
+   * Use `value()` for anything computed asynchronously
    */
-  detail?(): MaybePromise<unknown>;
+  readonly detail?: string;
+  /**
+   * Return RFC 9457 extension members added to the problem document,
+   * synchronously
+   *
+   * `type`, `code` and `status` stay the error's own. A string `detail` is
+   * served when the error has no `detail` of its own, in place of the
+   * message. `title` and `instance` may be overridden. Not served when
+   * `value()` answers
+   *
+   * Only a plain object's own data members are served, which types can't
+   * check: return an object literal, not a class instance
+   *
+   * @example
+   * ```ts
+   * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {
+   *     constructor(readonly balance: number) {
+   *         super()
+   *     }
+   *
+   *     extension() {
+   *         return { balance: this.balance, accounts: ['/account/12345'] }
+   *     }
+   * }
+   * ```
+   */
+  extension?(): Record<string, unknown>;
   /**
    * Create a concrete `HTTPError` subclass carrying `code`, mirrored into
    * `type` unless {@link HTTPError.typeBase} is set
@@ -362,16 +370,14 @@ declare abstract class HTTPError<const in out T extends string = string> extends
    * Create a concrete `HTTPError` subclass carrying `code`, 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`
+   * Annotate what is served with `detail` (problem `detail` member) or
+   * `value()` (whole-response override, may be `async`)
    *
    * @example
    * ```ts
    * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {}
    * class Denied extends HTTPError.id('DENIED', 'Payment Required') {
-   *     async detail() {
-   *         return await describeBalance()
-   *     }
+   *     override readonly detail = 'Top up to continue'
    * }
    * ```
    */

package/dist/handler/error.d.ts

@@ -22,13 +22,15 @@ declare const resolveStatus: (status: unknown) => unknown;
  * its declared `response`, otherwise its message, or `mask` in its place
  * on a production 5xx
  */
-declare function statusFallbackBody(error: any, status: unknown, mask?: string): any;
+declare function statusFallbackBody(error: any, status: unknown, mask?: string, asDetail?: boolean): any;
 /**
- * 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
+ * RFC 9457 extension members of an error claiming a problem type. Sync
+ * only: anything but a plain object, a Promise included, adds nothing.
+ * `type`, `code` and `status` stay the error's own, `detail` only when a
+ * string
  */
-declare const readAnnotation: (self: any, key: "value" | "detail", claimsProblem: boolean) => any;
+declare function extensionOf(self: any): any;
+declare function readAnnotation(self: any, key: 'value' | 'detail', claimsProblem: boolean): any;
 declare function createErrorHandler(onErrors: AppHook['error'] | undefined, mapResponse: (response: unknown, set: Context['set'], ...any: unknown[]) => unknown, allowUnsafe?: boolean): (context: Context, error: Error, sign?: ((set: Context["set"]) => unknown) | undefined) => unknown;
 //#endregion
-export { adoptErrorType, claimsProblemType, createErrorHandler, fallbackResponse, readAnnotation, resolveStatus, statusFallbackBody };
+export { adoptErrorType, claimsProblemType, createErrorHandler, extensionOf, fallbackResponse, readAnnotation, resolveStatus, statusFallbackBody };