elysia 1.4.28 → 2.0.0-beta.0

package/dist/error.js

@@ -1,366 +1,528 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants = require('./constants.js');
+const require_type_bridge = require('./type/bridge.js');
+const require_universal_is_production = require('./universal/is-production.js');
+const require_type_constants = require('./type/constants.js');
+const require_adapter_skip_clone = require('./adapter/skip-clone.js');
+
+//#region src/error.ts
+const expectedCache = /* @__PURE__ */ new WeakMap();
+function freezeExpected(value) {
+	if (!value || typeof value !== "object") return typeof value !== "function";
+	if (!Array.isArray(value) && value.constructor !== Object) return;
+	for (const key in value) if (!freezeExpected(value[key])) return;
+	return Object.freeze(value);
+}
+function isCacheableExpected(value, visited = /* @__PURE__ */ new Set()) {
+	if (value === null || value === void 0) return true;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean" || t === "bigint") return true;
+	if (t !== "object") return false;
+	const obj = value;
+	if (visited.has(obj)) return true;
+	const proto = Object.getPrototypeOf(obj);
+	if (proto !== Object.prototype && proto !== null && !Array.isArray(obj)) return false;
+	visited.add(obj);
+	for (const key in obj) if (!isCacheableExpected(obj[key], visited)) return false;
+	return true;
+}
+var ElysiaError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.problemType = "about:blank";
+		this.name = this.constructor.name;
+		if (cause) this.cause = cause;
+	}
+	toResponse(headers) {
+		return problemResponse({
+			type: this.problemType,
+			title: this.problemTitle,
+			status: this.status ?? 500,
+			detail: this.response !== void 0 && this.response !== this.problemTitle ? this.response : void 0
+		}, headers);
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var error_exports = {};
-__export(error_exports, {
-  ERROR_CODE: () => ERROR_CODE,
-  ElysiaCustomStatusResponse: () => ElysiaCustomStatusResponse,
-  ElysiaStatus: () => ElysiaStatus,
-  InternalServerError: () => InternalServerError,
-  InvalidCookieSignature: () => InvalidCookieSignature,
-  InvalidFileType: () => InvalidFileType,
-  NotFoundError: () => NotFoundError,
-  ParseError: () => ParseError,
-  ValidationError: () => ValidationError,
-  isProduction: () => isProduction,
-  mapValueError: () => mapValueError,
-  status: () => status
-});
-module.exports = __toCommonJS(error_exports);
-var import_value = require("@sinclair/typebox/value"), import_utils = require('./utils.js');
-const env = typeof Bun < "u" ? Bun.env : typeof process < "u" ? process?.env : void 0, ERROR_CODE = Symbol("ElysiaErrorCode"), isProduction = (env?.NODE_ENV ?? env?.ENV) === "production", emptyHttpStatus = {
-  101: void 0,
-  204: void 0,
-  205: void 0,
-  304: void 0,
-  307: void 0,
-  308: void 0
+/**
+* Wrap a string into a TypeBox `error` callback that overrides the default
+* validation message. Use as `t.Number({ error: validationDetail('x must be a number') })`.
+*/
+const validationDetail = (message) => (error) => {
+	error.message = message;
+	return error;
 };
-class ElysiaCustomStatusResponse {
-  constructor(code, response) {
-    const res = response ?? (code in import_utils.InvertedStatusMap ? (
-      // @ts-expect-error Always correct
-      import_utils.InvertedStatusMap[code]
-    ) : code);
-    this.code = import_utils.StatusMap[code] ?? code, code in emptyHttpStatus ? this.response = void 0 : this.response = res;
-  }
-}
-const ElysiaStatus = ElysiaCustomStatusResponse, status = (code, response) => new ElysiaCustomStatusResponse(code, response);
-class InternalServerError extends Error {
-  constructor(message) {
-    super(message ?? "INTERNAL_SERVER_ERROR");
-    this.code = "INTERNAL_SERVER_ERROR";
-    this.status = 500;
-  }
+var InternalServerError = class extends ElysiaError {
+	constructor(response = "Internal Server Error", cause) {
+		super(response, cause);
+		this.response = response;
+		this.status = 500;
+		this.problemType = "internal-server-error";
+		this.problemTitle = "Internal Server Error";
+	}
+};
+var NotFound = class extends ElysiaError {
+	constructor(response = "Not Found") {
+		super(response);
+		this.response = response;
+		this.status = 404;
+		this.problemType = "not-found";
+		this.problemTitle = "Not Found";
+	}
+};
+var ParseError = class extends ElysiaError {
+	constructor(cause) {
+		super("Bad Request", cause);
+		this.status = 400;
+		this.response = "Bad Request";
+		this.problemType = "parse";
+		this.problemTitle = "Bad Request";
+	}
+	toResponse(headers) {
+		const cause = this.cause;
+		return problemResponse({
+			type: this.problemType,
+			title: this.problemTitle,
+			status: 400,
+			detail: !require_universal_is_production.isProduction() && cause?.message != null ? String(cause.message) : void 0
+		}, headers);
+	}
+};
+const segmentString = (part) => typeof part === "object" && part !== null ? part.key + "" : part + "";
+const propertyAccessor = (path) => {
+	if (Array.isArray(path)) return path.length ? "/" + path.map(segmentString).join("/") : "root";
+	if (typeof path === "string") return path || "root";
+	return "root";
+};
+function walkComposition(schema, parts, seen = /* @__PURE__ */ new WeakSet()) {
+	if (parts.length === 0) return schema;
+	if (!schema || typeof schema !== "object" || seen.has(schema)) return;
+	seen.add(schema);
+	try {
+		const branches = schema.anyOf ?? schema.oneOf ?? schema.allOf;
+		if (Array.isArray(branches)) for (let i = 0; i < branches.length; i++) {
+			const result = walkComposition(branches[i], parts, seen);
+			if (result !== void 0) return result;
+		}
+		const [head, ...rest] = parts;
+		if (schema.properties?.[head]) return walkComposition(schema.properties[head], rest, seen);
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object") return walkComposition(schema.additionalProperties, rest, seen);
+		if (schema.items) return walkComposition(schema.items, rest, seen);
+	} finally {
+		seen.delete(schema);
+	}
 }
-class NotFoundError extends Error {
-  constructor(message) {
-    super(message ?? "NOT_FOUND");
-    this.code = "NOT_FOUND";
-    this.status = 404;
-  }
+const walkSubSchema = (schema, instancePath) => !schema || !instancePath ? schema : walkComposition(schema, instancePath.split("/").filter(Boolean));
+const FOUND_ECHO_LIMIT = 8192;
+const FOUND_ECHO_OMITTED = `[value exceeds ${FOUND_ECHO_LIMIT} byte echo limit]`;
+function jsonStringLengthWithin(value, budget) {
+	budget -= 2;
+	for (let i = 0; i < value.length && budget >= 0; i++) {
+		const code = value.charCodeAt(i);
+		if (code === 34 || code === 92) budget -= 2;
+		else if (code < 32) budget -= code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 2 : 6;
+		else if (code < 128) budget--;
+		else if (code < 2048) budget -= 2;
+		else if (code >= 55296 && code <= 56319) {
+			const low = value.charCodeAt(i + 1);
+			if (low >= 56320 && low <= 57343) {
+				budget -= 4;
+				i++;
+			} else budget -= 6;
+		} else if (code >= 56320 && code <= 57343) budget -= 6;
+		else budget -= 3;
+	}
+	return budget;
 }
-class ParseError extends Error {
-  constructor(cause) {
-    super("Bad Request", {
-      cause
-    });
-    this.code = "PARSE";
-    this.status = 400;
-  }
+const jsonLengthWithin = (value, budget) => {
+	if (budget < 0) return -1;
+	switch (typeof value) {
+		case "object": break;
+		case "string": return jsonStringLengthWithin(value, budget);
+		case "number": return budget - (Number.isFinite(value) ? String(value).length : 4);
+		case "boolean": return budget - (value ? 4 : 5);
+		default: return budget - 4;
+	}
+	if (value === null) return budget - 4;
+	if (Array.isArray(value)) {
+		budget -= 2;
+		for (let i = 0; i < value.length; i++) {
+			budget = jsonLengthWithin(value[i], budget - (i ? 1 : 0));
+			if (budget < 0) return -1;
+		}
+		return budget;
+	}
+	budget -= 2;
+	let first = true;
+	for (const key in value) {
+		budget = jsonStringLengthWithin(key, budget - (first ? 0 : 1)) - 1;
+		if (budget < 0) return -1;
+		budget = jsonLengthWithin(value[key], budget);
+		if (budget < 0) return -1;
+		first = false;
+	}
+	return budget;
+};
+function subValueAt(value, path) {
+	let parts;
+	if (typeof path === "string") parts = path.split("/").filter(Boolean);
+	else if (Array.isArray(path)) parts = path;
+	if (!parts) return;
+	let current = value;
+	for (let i = 0; i < parts.length; i++) {
+		if (current === null || typeof current !== "object") return;
+		const part = parts[i];
+		current = current[typeof part === "object" && part !== null ? part.key : part];
+	}
+	return current;
 }
-class InvalidCookieSignature extends Error {
-  constructor(key, message) {
-    super(message ?? `"${key}" has invalid cookie signature`);
-    this.key = key;
-    this.code = "INVALID_COOKIE_SIGNATURE";
-    this.status = 400;
-  }
+function scopeFound(value, first) {
+	if (jsonLengthWithin(value, FOUND_ECHO_LIMIT) >= 0) return value;
+	const sub = subValueAt(value, first?.instancePath ?? first?.path);
+	if (sub !== void 0 && jsonLengthWithin(sub, FOUND_ECHO_LIMIT) >= 0) return sub;
+	return FOUND_ECHO_OMITTED;
 }
-const mapValueError = (error) => {
-  if (!error) return error;
-  let { message, path, value, type } = error;
-  Array.isArray(path) && (path = path[0]);
-  const property = typeof path == "string" ? path.slice(1).replaceAll("/", ".") : "unknown", isRoot = path === "";
-  switch (type) {
-    case 42:
-      return {
-        ...error,
-        summary: isRoot ? "Value should not be provided" : `Property '${property}' should not be provided`
-      };
-    case 45:
-      return {
-        ...error,
-        summary: isRoot ? "Value is missing" : `Property '${property}' is missing`
-      };
-    case 50:
-      const quoteIndex = message.indexOf("'"), format = message.slice(
-        quoteIndex + 1,
-        message.indexOf("'", quoteIndex + 1)
-      );
-      return {
-        ...error,
-        summary: isRoot ? "Value should be an email" : `Property '${property}' should be ${format}`
-      };
-    case 54:
-      return {
-        ...error,
-        summary: `${message.slice(0, 9).trim()} property '${property}' to be ${message.slice(8).trim()} but found: ${value}`
-      };
-    case 62:
-      const union = error.schema.anyOf.map((x) => `'${x?.format ?? x.type}'`).join(", ");
-      return {
-        ...error,
-        summary: isRoot ? `Value should be one of ${union}` : `Property '${property}' should be one of: ${union}`
-      };
-    default:
-      return { summary: message, ...error };
-  }
+var ValidationError = class extends ElysiaError {
+	#thunk;
+	#findCustomError;
+	#state;
+	constructor(type, value, errors, schema, findCustomError) {
+		super(void 0);
+		this.type = type;
+		this.value = value;
+		this.status = 422;
+		this.allowUnsafeValidationDetails = false;
+		this.schema = schema;
+		this.#thunk = typeof errors === "function" ? errors : () => errors;
+		this.#findCustomError = findCustomError;
+		Object.defineProperty(this, "errors", {
+			get: () => this["~resolve"]().errors,
+			set(v) {
+				Object.defineProperty(this, "errors", {
+					value: v,
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+			},
+			enumerable: true,
+			configurable: true
+		});
+	}
+	/** @internal lazily resolve and memoize errors/customError/message */
+	"~resolve"() {
+		if (this.#state) return this.#state;
+		const { type, value } = this;
+		const production = require_universal_is_production.isProduction();
+		const allowUnsafe = this.allowUnsafeValidationDetails;
+		const findCustomError = this.#findCustomError;
+		let resolved;
+		let custom;
+		let message;
+		if (production && !allowUnsafe && findCustomError) {
+			const hit = findCustomError(value);
+			resolved = hit ? [{ instancePath: hit.instancePath }] : [];
+			if (hit && hit.error !== void 0) custom = typeof hit.error === "function" ? hit.error({
+				type: "validation",
+				on: type,
+				found: void 0
+			}) : hit.error;
+			message = custom !== void 0 ? typeof custom === "string" ? custom : JSON.stringify(custom) : `Validation error on ${type ?? "unknown"}`;
+			return this.#state = {
+				errors: resolved,
+				custom,
+				message
+			};
+		}
+		resolved = this.#thunk() ?? [];
+		const sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+		if (sub?.error !== void 0) custom = typeof sub.error === "function" ? sub.error(production && !allowUnsafe ? {
+			type: "validation",
+			on: type,
+			found: void 0
+		} : {
+			type: "validation",
+			on: type,
+			value,
+			errors: resolved
+		}) : sub.error;
+		message = custom !== void 0 ? typeof custom === "string" ? custom : JSON.stringify(custom) : resolved[0]?.message ? resolved[0].message : `Validation error on ${type ?? "unknown"}`;
+		return this.#state = {
+			errors: resolved,
+			custom,
+			message
+		};
+	}
+	get customError() {
+		return this["~resolve"]().custom;
+	}
+	set customError(v) {
+		Object.defineProperty(this, "customError", {
+			value: v,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+	}
+	get all() {
+		if (!this.errors) return [];
+		return this.#collapseCoercionErrors(this.errors.filter(Boolean)).map((e) => this.#normalizeIssue(e));
+	}
+	#collapseCoercionErrors(errors) {
+		if (!this.schema || !errors.length) return errors;
+		let coercionPaths;
+		let seen;
+		let out;
+		for (let i = 0; i < errors.length; i++) {
+			const e = errors[i];
+			const path = e?.instancePath;
+			if (typeof path !== "string" || typeof e?.schemaPath !== "string" || e.keyword !== "anyOf" && !e.schemaPath.includes("/anyOf")) {
+				out?.push(e);
+				continue;
+			}
+			coercionPaths ??= /* @__PURE__ */ new Map();
+			let isCoercion = coercionPaths.get(path);
+			if (isCoercion === void 0) {
+				const sub = walkSubSchema(this.schema, path);
+				isCoercion = !!sub?.["~elyTyp"] && require_type_constants.primitiveElysiaTypes.has(sub["~elyTyp"]);
+				coercionPaths.set(path, isCoercion);
+			}
+			if (!isCoercion) {
+				out?.push(e);
+				continue;
+			}
+			out ??= errors.slice(0, i);
+			seen ??= /* @__PURE__ */ new Set();
+			if (seen.has(path)) continue;
+			seen.add(path);
+			const internal = e.keyword === "~refine" || e.keyword === "anyOf";
+			out.push({
+				...e,
+				keyword: internal ? "type" : e.keyword,
+				schemaPath: e.schemaPath.replace(/\/anyOf(\/\d+)?$/, ""),
+				params: internal ? {} : e.params,
+				message: internal ? e.params?.message ?? e.message : e.message
+			});
+		}
+		return out ?? errors;
+	}
+	#normalizeIssue(e) {
+		if (!e) return e;
+		return {
+			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",
+			message: e.message ?? "",
+			schemaPath: e.schemaPath,
+			params: e.params,
+			value: this.value
+		};
+	}
+	get #productionDetail() {
+		return require_universal_is_production.isProduction() && !this.allowUnsafeValidationDetails;
+	}
+	get #maskResponseValue() {
+		return this.type === "response" && this.#productionDetail;
+	}
+	detail(message) {
+		if (this.#productionDetail) {
+			if (this.type === "response") return {
+				type: "internal-server-error",
+				on: this.type,
+				message
+			};
+			return {
+				type: "validation",
+				on: this.type,
+				message
+			};
+		}
+		return {
+			type: "validation",
+			on: this.type,
+			message,
+			errors: this.all
+		};
+	}
+	get payload() {
+		if (this.#productionDetail) {
+			if (this.type === "response") return {
+				type: "internal-server-error",
+				title: "Internal Server Error",
+				status: 500
+			};
+			const first = (this.errors ?? []).find(Boolean);
+			return {
+				type: "validation",
+				title: "Validation Error",
+				status: 422,
+				on: this.type,
+				property: first ? propertyAccessor(first.instancePath ?? (Array.isArray(first.path) ? first.path : void 0)) : "root"
+			};
+		}
+		const errors = this.#collapseCoercionErrors((this.errors ?? []).filter(Boolean));
+		const first = errors[0];
+		const property = first ? propertyAccessor(first.instancePath ?? first.path) : "root";
+		const detail = first?.message ?? this.message;
+		let expected;
+		const schemaForExpected = first?.schema ?? this.schema;
+		if (schemaForExpected) if (expectedCache.has(schemaForExpected)) expected = expectedCache.get(schemaForExpected);
+		else try {
+			const created = require_type_bridge.Create(schemaForExpected);
+			if (isCacheableExpected(created)) try {
+				const snapshot = structuredClone(created);
+				expected = snapshot;
+				if (freezeExpected(snapshot)) expectedCache.set(schemaForExpected, snapshot);
+			} catch {
+				expected = created;
+			}
+			else expected = created;
+		} catch {}
+		return {
+			type: "validation",
+			title: "Validation Error",
+			status: 422,
+			detail,
+			on: this.type,
+			property,
+			found: scopeFound(this.value, first),
+			expected,
+			errors
+		};
+	}
+	toResponse(headers) {
+		if (this.#maskResponseValue) return problemResponse(this.payload, headers);
+		if (this.customError !== void 0) {
+			const isString = typeof this.customError === "string";
+			const response = new Response(isString ? this.customError : JSON.stringify(this.customError), {
+				status: this.status ?? 422,
+				headers: {
+					...headers,
+					"content-type": isString ? "text/plain" : "application/json"
+				}
+			});
+			require_adapter_skip_clone.skipClone.add(response);
+			return response;
+		}
+		return problemResponse(this.payload, headers);
+	}
+};
+Object.defineProperty(ValidationError.prototype, "message", {
+	get() {
+		return this["~resolve"]().message;
+	},
+	set(v) {
+		Object.defineProperty(this, "message", {
+			value: v,
+			writable: true,
+			enumerable: false,
+			configurable: true
+		});
+	},
+	enumerable: false,
+	configurable: true
+});
+const emptyHttpStatus = new Set([
+	101,
+	204,
+	205,
+	304,
+	307,
+	308
+]);
+var ElysiaStatus = class {
+	constructor(code, res, headers) {
+		const response = res ?? (code in require_constants.StatusMapBack ? require_constants.StatusMapBack[code] : code);
+		this.code = require_constants.StatusMap[code] ?? code;
+		if (!emptyHttpStatus.has(this.code)) this.response = response;
+		this.headers = headers;
+	}
+	get status() {
+		return this.code;
+	}
 };
-class InvalidFileType extends Error {
-  constructor(property, expected, message = `"${property}" has invalid file type`) {
-    super(message);
-    this.property = property;
-    this.expected = expected;
-    this.message = message;
-    this.code = "INVALID_FILE_TYPE";
-    this.status = 422;
-    Object.setPrototypeOf(this, InvalidFileType.prototype);
-  }
-  toResponse(headers) {
-    return isProduction ? new Response(
-      JSON.stringify({
-        type: "validation",
-        on: "body"
-      }),
-      {
-        status: 422,
-        headers: {
-          ...headers,
-          "content-type": "application/json"
-        }
-      }
-    ) : new Response(
-      JSON.stringify({
-        type: "validation",
-        on: "body",
-        summary: "Invalid file type",
-        message: this.message,
-        property: this.property,
-        expected: this.expected
-      }),
-      {
-        status: 422,
-        headers: {
-          ...headers,
-          "content-type": "application/json"
-        }
-      }
-    );
-  }
+const status = (code, response) => new ElysiaStatus(code, response);
+const PROBLEM_JSON = "application/problem+json";
+function problemBody(p) {
+	const status = typeof p.status === "string" ? require_constants.StatusMap[p.status] ?? 500 : p.status ?? 500;
+	const body = {
+		type: "about:blank",
+		...p,
+		status
+	};
+	if (body.title == null) body.title = require_constants.StatusMapBack[status] ?? "Error";
+	return body;
 }
-class ValidationError extends Error {
-  constructor(type, validator, value, allowUnsafeValidationDetails = !1, errors) {
-    let message = "", error, expected, customError;
-    if (
-      // @ts-ignore
-      validator?.provider === "standard" || "~standard" in validator || // @ts-ignore
-      validator.schema && "~standard" in validator.schema
-    ) {
-      const standard = (
-        // @ts-ignore
-        ("~standard" in validator ? validator : validator.schema)["~standard"]
-      );
-      error = (errors ?? standard.validate(value).issues)?.[0], isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
-        type: "validation",
-        on: type,
-        found: value
-      }) : message = JSON.stringify(
-        {
-          type: "validation",
-          on: type,
-          property: error.path?.[0] || "root",
-          message: error?.message,
-          summary: error?.problem,
-          expected,
-          found: value,
-          errors
-        },
-        null,
-        2
-      ), customError = error?.message;
-    } else {
-      value && typeof value == "object" && value instanceof ElysiaCustomStatusResponse && (value = value.response), error = errors?.First() ?? ("Errors" in validator ? validator.Errors(value).First() : import_value.Value.Errors(validator, value).First());
-      const accessor = error?.path || "root", schema = validator?.schema ?? validator;
-      if (!isProduction && !allowUnsafeValidationDetails)
-        try {
-          expected = import_value.Value.Create(schema);
-        } catch (error2) {
-          expected = {
-            type: "Could not create expected value",
-            // @ts-expect-error
-            message: error2?.message,
-            error: error2
-          };
-        }
-      customError = error?.schema?.message || error?.schema?.error !== void 0 ? typeof error.schema.error == "function" ? error.schema.error(
-        isProduction && !allowUnsafeValidationDetails ? {
-          type: "validation",
-          on: type,
-          found: value
-        } : {
-          type: "validation",
-          on: type,
-          value,
-          property: accessor,
-          message: error?.message,
-          summary: mapValueError(error)?.summary,
-          found: value,
-          expected,
-          errors: "Errors" in validator ? [
-            ...validator.Errors(
-              value
-            )
-          ].map(mapValueError) : [
-            ...import_value.Value.Errors(
-              validator,
-              value
-            )
-          ].map(mapValueError)
-        },
-        validator
-      ) : error.schema.error : void 0, customError !== void 0 ? message = typeof customError == "object" ? JSON.stringify(customError) : customError + "" : isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
-        type: "validation",
-        on: type,
-        found: value
-      }) : message = JSON.stringify(
-        {
-          type: "validation",
-          on: type,
-          property: accessor,
-          message: error?.message,
-          summary: mapValueError(error)?.summary,
-          expected,
-          found: value,
-          errors: "Errors" in validator ? [...validator.Errors(value)].map(
-            mapValueError
-          ) : [...import_value.Value.Errors(validator, value)].map(
-            mapValueError
-          )
-        },
-        null,
-        2
-      );
-    }
-    super(message);
-    this.type = type;
-    this.validator = validator;
-    this.value = value;
-    this.allowUnsafeValidationDetails = allowUnsafeValidationDetails;
-    this.code = "VALIDATION";
-    this.status = 422;
-    this.valueError = error, this.expected = expected, this.customError = customError, Object.setPrototypeOf(this, ValidationError.prototype);
-  }
-  /**
-   * Alias of `valueError`
-   */
-  get messageValue() {
-    return this.valueError;
-  }
-  get all() {
-    return (
-      // @ts-ignore
-      this.validator?.provider === "standard" || "~standard" in this.validator || // @ts-ignore
-      "schema" in this.validator && // @ts-ignore
-      this.validator.schema && // @ts-ignore
-      "~standard" in this.validator.schema ? /* @ts-ignore */ ("~standard" in this.validator ? this.validator : (
-        // @ts-ignore
-        this.validator.schema
-      ))["~standard"].validate(this.value).issues?.map((issue) => ({
-        summary: issue.message,
-        path: issue.path?.join(".") || "root",
-        message: issue.message,
-        value: this.value
-      })) || [] : "Errors" in this.validator ? [...this.validator.Errors(this.value)].filter((x) => x).map((x) => mapValueError(x)) : (
-        // @ts-ignore
-        [...import_value.Value.Errors(this.validator, this.value)].map(mapValueError)
-      )
-    );
-  }
-  static simplifyModel(validator) {
-    const model = "schema" in validator ? validator.schema : validator;
-    try {
-      return import_value.Value.Create(model);
-    } catch {
-      return model;
-    }
-  }
-  get model() {
-    return "~standard" in this.validator ? this.validator : ValidationError.simplifyModel(this.validator);
-  }
-  toResponse(headers) {
-    return new Response(this.message, {
-      status: 400,
-      headers: {
-        ...headers,
-        "content-type": "application/json"
-      }
-    });
-  }
-  /**
-   * Utility function to inherit add custom error and keep the original Validation error
-   *
-   * @since 1.3.14
-   *
-   * @example
-   * ```ts
-   * new Elysia()
-   *		.onError(({ error, code }) => {
-   *			if (code === 'VALIDATION') return error.detail(error.message)
-   *		})
-   *		.post('/', () => 'Hello World!', {
-   *			body: t.Object({
-   *				x: t.Number({
-   *					error: 'x must be a number'
-   *				})
-   *			})
-   *		})
-   * ```
-   */
-  detail(message, allowUnsafeValidatorDetails = this.allowUnsafeValidationDetails) {
-    if (!this.customError) return this.message;
-    const value = this.value, expected = this.expected, errors = this.all;
-    return isProduction && !allowUnsafeValidatorDetails ? {
-      type: "validation",
-      on: this.type,
-      found: value,
-      message
-    } : {
-      type: "validation",
-      on: this.type,
-      property: this.valueError?.path || "root",
-      message,
-      summary: mapValueError(this.valueError)?.summary,
-      found: value,
-      expected,
-      errors
-    };
-  }
+function problemResponse(p, headers) {
+	const body = problemBody(p);
+	const response = new Response(emptyHttpStatus.has(body.status) ? null : JSON.stringify(body), {
+		status: body.status,
+		headers: {
+			...headers,
+			"content-type": PROBLEM_JSON
+		}
+	});
+	require_adapter_skip_clone.skipClone.add(response);
+	return response;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ERROR_CODE,
-  ElysiaCustomStatusResponse,
-  ElysiaStatus,
-  InternalServerError,
-  InvalidCookieSignature,
-  InvalidFileType,
-  NotFoundError,
-  ParseError,
-  ValidationError,
-  isProduction,
-  mapValueError,
-  status
-});
+function internalServerErrorBody(error) {
+	const body = {
+		type: "internal-server-error",
+		title: "Internal Server Error",
+		status: 500
+	};
+	if (!require_universal_is_production.isProduction()) {
+		if (error?.message != null) body.detail = error.message;
+		if (error?.name) body.name = error.name;
+		if (error?.cause !== void 0) body.cause = error.cause;
+	}
+	return body;
+}
+function internalServerErrorBodyString(error) {
+	try {
+		return JSON.stringify(internalServerErrorBody(error));
+	} catch {
+		try {
+			const safe = internalServerErrorBody(error);
+			delete safe.cause;
+			return JSON.stringify(safe);
+		} catch {
+			return JSON.stringify({
+				type: "internal-server-error",
+				title: "Internal Server Error",
+				status: 500
+			});
+		}
+	}
+}
+function internalServerErrorResponse(error) {
+	const body = internalServerErrorBodyString(error);
+	const response = new Response(body, {
+		status: 500,
+		headers: { "content-type": PROBLEM_JSON }
+	});
+	require_adapter_skip_clone.skipClone.add(response);
+	return response;
+}
+function problem(statusOrDetail, detail) {
+	const body = typeof statusOrDetail === "object" ? statusOrDetail : {
+		...detail,
+		status: statusOrDetail
+	};
+	return new ElysiaStatus(body.status ?? 500, problemBody(body), { "content-type": PROBLEM_JSON });
+}
+
+//#endregion
+exports.ElysiaError = ElysiaError;
+exports.ElysiaStatus = ElysiaStatus;
+exports.InternalServerError = InternalServerError;
+exports.NotFound = NotFound;
+exports.PROBLEM_JSON = PROBLEM_JSON;
+exports.ParseError = ParseError;
+exports.ValidationError = ValidationError;
+exports.internalServerErrorBody = internalServerErrorBody;
+exports.internalServerErrorBodyString = internalServerErrorBodyString;
+exports.internalServerErrorResponse = internalServerErrorResponse;
+exports.isProduction = require_universal_is_production.isProduction;
+exports.problem = problem;
+exports.problemBody = problemBody;
+exports.problemResponse = problemResponse;
+exports.status = status;
+exports.subValueAt = subValueAt;
+exports.validationDetail = validationDetail;