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

package/dist/cookie/utils.mjs

@@ -1,9 +1,10 @@
+// @bun
 import { nullObject } from "../utils.mjs";
 import { InvalidCookie } from "./error.mjs";
 import { parse } from "./lib.mjs";
 import { deriveSignKey, hasSyncHmac, maybeJsonDecode, rawJsonValue, resolvePendingCookie, signCookie, signCookieSyncImpl, unsignWithSecrets, unsignWithSecretsSync } from "./crypto.mjs";
 import { Cookie } from "./cookie.mjs";
-import { isCookieSigned, legacySignatureOf, resolveSignSecrets } from "./config.mjs";
+import { acceptsLegacySignature, isCookieSigned, resolveSignSecrets } from "./config.mjs";
 import decodeComponent from "deuri";
 
 //#region src/cookie/utils.ts
@@ -40,13 +41,13 @@ function parseCookieRawLazy(cookieString, config) {
 	return out;
 }
 /**
-* Raw-record value of a signed cookie that failed verification on a lane that
-* can't verify on access (asynchronous HMAC, AOT); the jar rejects its first
-* read. A string key, not a module identity, so a second Elysia copy agrees.
-* Null-prototype, which `JSON.parse` never yields, so no cookie value a client
-* sends (unsigned, or accepted by a `null` rotation secret) can take its shape
+* Stands in for a signed cookie that failed verification on a lane that can't
+* verify on access (async HMAC, AOT); the jar rejects its first read.
+* String key so a second Elysia copy agrees; null-prototype, which
+* `JSON.parse` never yields, so no client-sent value (unsigned, or accepted by a
+* `null` rotation secret) can forge it
 */
-const invalidSignature = () => {
+const invalidSignatureMarker = () => {
 	const marker = nullObject();
 	marker["~invalid"] = 1;
 	return marker;
@@ -63,10 +64,10 @@ async function parseCookieRaw(cookieString, config, lazy) {
 		let value = decodeComponent(v) ?? v;
 		const signCheck = resolveSignSecrets(name, config);
 		if (signCheck !== void 0) try {
-			value = await unsignWithSecrets(name, value, signCheck, legacySignatureOf(name, config));
+			value = await unsignWithSecrets(name, value, signCheck, acceptsLegacySignature(name, config));
 		} catch (error) {
 			if (!lazy || !(error instanceof InvalidCookie)) throw error;
-			out[name] = invalidSignature();
+			out[name] = invalidSignatureMarker();
 			continue;
 		}
 		out[name] = maybeJsonDecode(value);
@@ -84,31 +85,38 @@ function parseCookieRawSigned(cookieString, config, lazy) {
 		let value = decodeComponent(v) ?? v;
 		const signCheck = resolveSignSecrets(name, config);
 		if (signCheck !== void 0) try {
-			value = unsignWithSecretsSync(name, value, signCheck, legacySignatureOf(name, config));
+			value = unsignWithSecretsSync(name, value, signCheck, acceptsLegacySignature(name, config));
 		} catch (error) {
 			if (!lazy || !(error instanceof InvalidCookie)) throw error;
-			out[name] = invalidSignature();
+			out[name] = invalidSignatureMarker();
 			continue;
 		}
 		out[name] = maybeJsonDecode(value);
 	}
 	return out;
 }
-function buildCookieJar(set, raw, config, lazySign, deferDecode) {
-	const store = raw;
-	const materialized = nullObject();
-	function materializeEntry(name) {
-		if (materialized[name]) return store[name];
+var CookieJarHandler = class {
+	constructor(setRef, config, lazySign, deferDecode) {
+		this.setRef = setRef;
+		this.config = config;
+		this.lazySign = lazySign;
+		this.deferDecode = deferDecode;
+		this.materialized = void 0;
+		this.cache = void 0;
+	}
+	materialize(store, name) {
+		if (this.materialized?.[name]) return store[name];
+		const config = this.config;
 		const rawValue = store[name];
 		const fieldDefaults = config.fields[name]?.defaults;
-		const entry = Object.assign(nullObject(), config.defaults, fieldDefaults, { value: deferDecode ? maybeJsonDecode(decodeComponent(rawValue) ?? rawValue) : rawValue });
+		const entry = Object.assign(nullObject(), config.defaults, fieldDefaults, { value: this.deferDecode ? maybeJsonDecode(decodeComponent(rawValue) ?? rawValue) : rawValue });
 		if (entry.expires instanceof Date) entry.expires = new Date(entry.expires.getTime());
 		if (rawValue?.["~invalid"] === 1 && Object.getPrototypeOf(rawValue) === null) entry["~unsign"] = 1;
-		else if (lazySign && typeof entry.value === "string") {
+		else if (this.lazySign && typeof entry.value === "string") {
 			const secrets = resolveSignSecrets(name, config);
 			if (secrets !== void 0) {
 				entry["~unsign"] = secrets;
-				if (!legacySignatureOf(name, config)) entry["~strict"] = 1;
+				if (!acceptsLegacySignature(name, config)) entry["~strict"] = 1;
 			}
 		} else {
 			const value = entry.value;
@@ -118,33 +126,33 @@ function buildCookieJar(set, raw, config, lazySign, deferDecode) {
 			}
 		}
 		store[name] = entry;
-		materialized[name] = 1;
+		(this.materialized ??= nullObject())[name] = 1;
 		return entry;
 	}
-	const cache = nullObject();
-	function settle(key) {
+	settle(store, key) {
 		if (!(key in store)) return;
-		const entry = materializeEntry(key);
+		const entry = this.materialize(store, key);
 		if ("~unsign" in entry) resolvePendingCookie(entry, key);
 	}
-	return new Proxy(store, {
-		get(_, key) {
-			return cache[key] ??= new Cookie(key, set, key in store ? materializeEntry(key) : Object.assign(nullObject(), config.defaults, config.fields[key]?.defaults));
-		},
-		has(target, key) {
-			if (typeof key === "string") settle(key);
-			return Reflect.has(target, key);
-		},
-		ownKeys(target) {
-			const keys = Reflect.ownKeys(target);
-			for (let i = 0; i < keys.length; i++) settle(keys[i]);
-			return keys;
-		},
-		getOwnPropertyDescriptor(target, key) {
-			if (typeof key === "string") settle(key);
-			return Reflect.getOwnPropertyDescriptor(target, key);
-		}
-	});
+	get(store, key) {
+		return (this.cache ??= nullObject())[key] ??= new Cookie(key, this.setRef, key in store ? this.materialize(store, key) : Object.assign(nullObject(), this.config.defaults, this.config.fields[key]?.defaults));
+	}
+	has(store, key) {
+		if (typeof key === "string") this.settle(store, key);
+		return Reflect.has(store, key);
+	}
+	ownKeys(store) {
+		const keys = Reflect.ownKeys(store);
+		for (let i = 0; i < keys.length; i++) this.settle(store, keys[i]);
+		return keys;
+	}
+	getOwnPropertyDescriptor(store, key) {
+		if (typeof key === "string") this.settle(store, key);
+		return Reflect.getOwnPropertyDescriptor(store, key);
+	}
+};
+function buildCookieJar(set, raw, config, lazySign, deferDecode) {
+	return new Proxy(raw, new CookieJarHandler(set, config, lazySign, deferDecode));
 }
 function collectSignPending(cookies, config) {
 	if (!cookies || !config.hasSign) return;
@@ -171,12 +179,24 @@ function collectSignPending(cookies, config) {
 	}
 	return pending;
 }
-function dropSigned(cookies, config) {
-	for (const name in cookies) if (config.fields[name]?.sign || config.globalSign === true || config.globalSignSet?.has(name)) delete cookies[name];
+function dropSigned(cookies, config, set) {
+	if (set) Object.defineProperty(set, "~signFailed", {
+		value: true,
+		configurable: true
+	});
+	const signed = (name) => config.fields[name]?.sign || config.globalSign === true || config.globalSignSet?.has(name);
+	let kept = false;
+	for (const name in cookies) if (signed(name) && !Reflect.deleteProperty(cookies, name)) kept = true;
+	if (kept && set?.cookie === cookies) {
+		const copy = nullObject();
+		for (const name in cookies) if (!signed(name)) copy[name] = cookies[name];
+		set.cookie = copy;
+	}
 }
-function signCookieValues(cookies, config) {
+function signCookieValues(cookies, config, set) {
 	let pending;
 	try {
+		if (set?.["~signFailed"]) throw new TypeError("A signed cookie of this request failed to sign");
 		pending = collectSignPending(cookies, config);
 		if (!pending) return;
 		if (hasSyncHmac) {
@@ -187,11 +207,11 @@ function signCookieValues(cookies, config) {
 			return;
 		}
 	} catch (error) {
-		dropSigned(cookies, config);
+		dropSigned(cookies, config, set);
 		throw error;
 	}
 	return signPending(pending).catch((error) => {
-		dropSigned(cookies, config);
+		dropSigned(cookies, config, set);
 		throw error;
 	});
 }

package/dist/error.d.ts

@@ -181,6 +181,8 @@ type ProblemResponseBody<Status extends number, P> = Omit<{
 }, keyof P> & Omit<P, 'status'> & {
   status: Status;
 };
+/** Title of a status, as `problemBody` fills it */
+declare const titleOf: (status: number) => string;
 declare function problemBody(p: Problem): Record<string, unknown> & {
   status: number;
 };
@@ -234,9 +236,9 @@ type TaggedHTTPError<Type extends string, Annotation = {}> = {
  * 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`
+ * `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
  *
  * - `detail()` - the common case. Whatever it returns becomes the `detail`
  *   member of the problem document, verbatim, objects included. The envelope
@@ -303,8 +305,10 @@ declare abstract class HTTPError<const in out T extends string = string> extends
   readonly code?: string;
   /**
    * Absolute base for the RFC 9457 `type` URI, applied to every class made
-   * by {@link HTTPError.id} and to every built-in `ElysiaError`
-   * (`NotFound`, `ParseError`, …) both derive `type` from the same slug
+   * by {@link HTTPError.id} and to the built-in `ElysiaError`s (`NotFound`,
+   * `ParseError`, `InvalidCookie`, `InternalServerError`) both derive `type`
+   * from the same slug. Request validation is the exception, it keeps
+   * `type: 'validation'` unprefixed
    *
    * @example
    * ```ts
@@ -375,4 +379,4 @@ declare abstract class HTTPError<const in out T extends string = string> extends
   }>;
 }
 //#endregion
-export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, MAX_ERRORS, NotFound, NumericStatus, PROBLEM_JSON, ParseError, Problem, ProblemResponseBody, SelectiveProblem, SelectiveStatus, StatusResponse, TaggedHTTPError, ValidationError, ValidationErrorResponse, elysiaErrorProblem, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, problemTypeOf, status, subValueAt, validationDetail };
+export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, MAX_ERRORS, NotFound, NumericStatus, PROBLEM_JSON, ParseError, Problem, ProblemResponseBody, SelectiveProblem, SelectiveStatus, StatusResponse, TaggedHTTPError, ValidationError, ValidationErrorResponse, elysiaErrorProblem, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, problemTypeOf, status, subValueAt, titleOf, validationDetail };

package/dist/error.js

@@ -304,7 +304,14 @@ var ValidationError = class extends ElysiaError {
 			resolved = this.#thunk() ?? [];
 			if (resolved.length > 64) resolved = resolved.slice(0, 64);
 			resolved = scopeIssues(resolved);
-			const sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+			let sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+			const missing = resolved[0]?.keyword === "required" && sub?.properties ? resolved[0].params?.requiredProperties : void 0;
+			if (Array.isArray(missing)) {
+				for (const key of missing) if (sub.properties[key]?.error !== void 0) {
+					sub = sub.properties[key];
+					break;
+				}
+			}
 			if (sub?.error !== void 0) custom = typeof sub.error === "function" ? sub.error(production && !allowUnsafe ? {
 				type: "validation",
 				on: type,
@@ -333,8 +340,9 @@ var ValidationError = class extends ElysiaError {
 		if (!this.errors) return [];
 		return this.#collapseCoercionErrors(this.errors.filter(Boolean)).map((e) => {
 			if (!e) return e;
+			const raw = e.path ?? e.instancePath;
 			const issue = {
-				path: Array.isArray(e.path) ? e.path.length ? e.path.map(segmentString).join(".") : "root" : typeof e.path === "string" ? e.path.replace(/^\//, "").replace(/\//g, ".") || "root" : "root",
+				path: Array.isArray(raw) && raw.length ? raw.map(segmentString).join(".") : typeof raw === "string" && raw ? raw.replace(/^\//, "").replace(/\//g, ".") : "root",
 				message: e.message ?? "",
 				schemaPath: e.schemaPath,
 				params: e.params
@@ -492,12 +500,19 @@ var ElysiaStatus = class {
 		const response = res ?? (code in require_constants.StatusMapBack ? require_constants.StatusMapBack[code] : code);
 		this.status = require_constants.StatusMap[code] ?? code;
 		if (!emptyHttpStatus.has(this.status)) this.response = response;
+		else if (headers) {
+			const kept = {};
+			for (const key of Object.keys(headers)) if (key.toLowerCase() !== "content-type") kept[key] = headers[key];
+			headers = kept;
+		}
 		this.headers = headers;
 	}
 };
 Object.defineProperty(ElysiaStatus, "name", { value: "ElysiaStatus" });
 const status = (code, response) => new ElysiaStatus(code, response);
 const PROBLEM_JSON = "application/problem+json";
+/** Title of a status, as `problemBody` fills it */
+const titleOf = (status) => require_constants.StatusMapBack[status] ?? "Error";
 function problemBody(p) {
 	const status = typeof p.status === "string" ? require_constants.StatusMap[p.status] ?? 500 : p.status ?? 500;
 	const body = {
@@ -505,7 +520,7 @@ function problemBody(p) {
 		...p,
 		status
 	};
-	if (body.title == null) body.title = require_constants.StatusMapBack[status] ?? "Error";
+	body.title ??= titleOf(status);
 	return body;
 }
 function problemResponse(p, headers) {
@@ -571,9 +586,9 @@ function problem(statusOrDetail, detail) {
 * 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`
+* `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
 *
 * - `detail()` - the common case. Whatever it returns becomes the `detail`
 *   member of the problem document, verbatim, objects included. The envelope
@@ -662,4 +677,5 @@ exports.problemResponse = problemResponse;
 exports.problemTypeOf = problemTypeOf;
 exports.status = status;
 exports.subValueAt = subValueAt;
+exports.titleOf = titleOf;
 exports.validationDetail = validationDetail;

package/dist/error.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { StatusMap, StatusMapBack } from "./constants.mjs";
 import { Create } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
@@ -48,7 +49,7 @@ function problemTypeOf(code) {
 }
 /**
 * Problem members an `ElysiaError` serves. `title` is left to `problemBody`,
-* which derives it from the status — so `response` is only worth serving as
+* which derives it from the status \u2014 so `response` is only worth serving as
 * `detail` when it says something the title doesn't
 */
 function elysiaErrorProblem(error) {
@@ -303,7 +304,14 @@ var ValidationError = class extends ElysiaError {
 			resolved = this.#thunk() ?? [];
 			if (resolved.length > 64) resolved = resolved.slice(0, 64);
 			resolved = scopeIssues(resolved);
-			const sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+			let sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+			const missing = resolved[0]?.keyword === "required" && sub?.properties ? resolved[0].params?.requiredProperties : void 0;
+			if (Array.isArray(missing)) {
+				for (const key of missing) if (sub.properties[key]?.error !== void 0) {
+					sub = sub.properties[key];
+					break;
+				}
+			}
 			if (sub?.error !== void 0) custom = typeof sub.error === "function" ? sub.error(production && !allowUnsafe ? {
 				type: "validation",
 				on: type,
@@ -332,8 +340,9 @@ var ValidationError = class extends ElysiaError {
 		if (!this.errors) return [];
 		return this.#collapseCoercionErrors(this.errors.filter(Boolean)).map((e) => {
 			if (!e) return e;
+			const raw = e.path ?? e.instancePath;
 			const issue = {
-				path: Array.isArray(e.path) ? e.path.length ? e.path.map(segmentString).join(".") : "root" : typeof e.path === "string" ? e.path.replace(/^\//, "").replace(/\//g, ".") || "root" : "root",
+				path: Array.isArray(raw) && raw.length ? raw.map(segmentString).join(".") : typeof raw === "string" && raw ? raw.replace(/^\//, "").replace(/\//g, ".") : "root",
 				message: e.message ?? "",
 				schemaPath: e.schemaPath,
 				params: e.params
@@ -491,12 +500,19 @@ var ElysiaStatus = class {
 		const response = res ?? (code in StatusMapBack ? StatusMapBack[code] : code);
 		this.status = StatusMap[code] ?? code;
 		if (!emptyHttpStatus.has(this.status)) this.response = response;
+		else if (headers) {
+			const kept = {};
+			for (const key of Object.keys(headers)) if (key.toLowerCase() !== "content-type") kept[key] = headers[key];
+			headers = kept;
+		}
 		this.headers = headers;
 	}
 };
 Object.defineProperty(ElysiaStatus, "name", { value: "ElysiaStatus" });
 const status = (code, response) => new ElysiaStatus(code, response);
 const PROBLEM_JSON = "application/problem+json";
+/** Title of a status, as `problemBody` fills it */
+const titleOf = (status) => StatusMapBack[status] ?? "Error";
 function problemBody(p) {
 	const status = typeof p.status === "string" ? StatusMap[p.status] ?? 500 : p.status ?? 500;
 	const body = {
@@ -504,7 +520,7 @@ function problemBody(p) {
 		...p,
 		status
 	};
-	if (body.title == null) body.title = StatusMapBack[status] ?? "Error";
+	body.title ??= titleOf(status);
 	return body;
 }
 function problemResponse(p, headers) {
@@ -570,9 +586,9 @@ function problem(statusOrDetail, detail) {
 * 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`
+* `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
 *
 * - `detail()` - the common case. Whatever it returns becomes the `detail`
 *   member of the problem document, verbatim, objects included. The envelope
@@ -594,7 +610,7 @@ function problem(statusOrDetail, detail) {
 * 		return { balance: 0, currency: 'usd' }
 * 	}
 * }
-* // → { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
+* // \u2192 { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
 * //     detail: { balance: 0, currency: 'usd' } }
 *
 * class Overdrawn extends HTTPError<'OVERDRAWN'> {
@@ -641,4 +657,4 @@ var HTTPError = class HTTPError extends Error {
 };
 
 //#endregion
-export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, MAX_ERRORS, NotFound, PROBLEM_JSON, ParseError, ValidationError, elysiaErrorProblem, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, problemTypeOf, status, subValueAt, validationDetail };
+export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, MAX_ERRORS, NotFound, PROBLEM_JSON, ParseError, ValidationError, elysiaErrorProblem, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, problemTypeOf, status, subValueAt, titleOf, validationDetail };

package/dist/generation.mjs

@@ -1,3 +1,4 @@
+// @bun
 //#region src/generation.ts
 const frozenRootOf = (root) => root["~generation"] ?? root;
 const resolvedTraceOf = (root) => frozenRootOf(root)["~ext"]?.capability?.trace?.provider;

package/dist/handler/error.d.ts

@@ -2,7 +2,12 @@ import { Context } from "../context.js";
 import { AppHook } from "../types.js";
 
 //#region src/handler/error.d.ts
-declare const claimsProblemType: (error: any) => boolean;
+/**
+ * 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
+ */
+declare const claimsProblemType: (error: any, type: unknown) => boolean;
 declare function adoptErrorType(result: any, error: any): any;
 /**
  * Response served once every error hook has declined the error.
@@ -11,25 +16,17 @@ declare function adoptErrorType(result: any, error: any): any;
  * 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): unknown;
-/**
- * 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'`
- */
 declare const resolveStatus: (status: unknown) => unknown;
 /**
  * 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
  */
-declare function statusFallbackBody(error: any, status: unknown): any;
+declare function statusFallbackBody(error: any, status: unknown, mask?: string): any;
 /**
- * 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
  */
 declare const 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;

package/dist/handler/error.js

@@ -31,14 +31,21 @@ function parseQuery(context) {
 	});
 }
 const isPristineNotFound = (context, error) => error instanceof require_error.NotFound && error.response === "Not Found" && !context.set.cookie && !require_utils.isNotEmpty(context.set.headers);
-const claimsProblemType = (error) => typeof error?.type === "string" ? !(error instanceof require_error.ValidationError) && error.constructor?.name !== "ValidationError" : error instanceof require_error.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 require_error.ValidationError) && error.constructor?.name !== "ValidationError" : error instanceof require_error.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 require_error.ElysiaStatus(result.status, {
 		...body,
-		type: error.type,
-		...typeof error.code === "string" ? { code: error.code } : {}
+		type,
+		...typeof code === "string" ? { code } : {}
 	}, result.headers);
 }
 /**
@@ -55,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" ? require_constants.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 = require_universal_is_production.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 require_error.ElysiaStatus(status, require_error.problemBody({
-	type: self.type ?? "about:blank",
-	...claimsProblem && typeof self.code === "string" ? { code: self.code } : {},
-	detail,
-	status
-}), { "content-type": require_error.PROBLEM_JSON });
+const problemOf = (self, type, detail, status, claimsProblem) => {
+	const code = claimsProblem ? self.code : void 0;
+	return new require_error.ElysiaStatus(status, require_error.problemBody({
+		type: typeof type === "string" ? type : "about:blank",
+		...typeof code === "string" ? { code } : {},
+		detail,
+		status
+	}), { "content-type": require_error.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];
@@ -98,7 +102,8 @@ function fallbackErrorResponse(context, error, mapResponse) {
 	const self = error ?? {};
 	const status = resolveStatus(self.status);
 	const owned = error instanceof require_error.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;
@@ -109,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(require_error.internalServerErrorResponse(error), context.set, context);
-		}
+		if (error?.message != null && (context.set.status === void 0 || context.set.status === 200)) context.set.status = 500;
 		return mapResponse(require_error.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, require_error.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 require_error.ValidationError) return mapResponse(error.type === "response" ? require_error.internalServerErrorResponse(void 0) : new require_error.ElysiaStatus(422, require_error.problemBody({
 		type: "validation",
@@ -142,7 +144,8 @@ function fallbackErrorResponse(context, error, mapResponse) {
 		title: "Validation Error",
 		status: 422
 	}), { "content-type": require_error.PROBLEM_JSON }), context.set, context);
-	if (owned || error instanceof Error && typeof status === "number" && status >= 100 && !(require_universal_is_production.isProduction() && status >= 500)) return tier("value");
+	if (owned || error instanceof Error && typeof status === "number" && status >= 100 && !(require_universal_is_production.isProduction() && status >= 500)) return serveAnnotation("value");
+	if (claimsProblem && error instanceof Error && typeof status === "number" && status >= 500) return mapResponse(problemOf(self, type, require_error.titleOf(status), status, false), context.set, context);
 	return legacy();
 }
 function applyErrorStatus(context, error) {
@@ -166,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) ? require_handler_utils.getNotFound() : fallbackResponse(context, error, mapWith(sign));
+	const serveUnhandled = (context, error, sign) => isPristineNotFound(context, error) ? require_handler_utils.getNotFound() : fallbackResponse(context, error, mapWith(sign));
 	if (require_handler_utils.hasAsync(onErrors)) return async (context, error, sign) => {
 		require_adapter_utils.materializeSetHeaders(context.set);
 		enter(context, error);
@@ -175,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) => {
 		require_adapter_utils.materializeSetHeaders(context.set);
@@ -184,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);
 	};
 }