elysia 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/type/elysia/object-string.js

@@ -10,17 +10,41 @@ const require_type_elysia_object = require('./object.js');
 let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/object-string.ts
+const MEMO_LIMIT = 8192;
 function ObjectString(property, _options) {
 	const [{ properties, ...constraints }, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
 	const object = require_type_elysia_object.ObjectType(property, constraints);
+	let check;
+	let raw;
+	let parsed;
 	const objectString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
 		if (value.charCodeAt(0) !== 123) return false;
+		if (value === raw) return true;
 		try {
-			return require_type_bridge.Check(object, JSON.parse(value));
+			const next = JSON.parse(value);
+			if (!check) try {
+				const compiled = require_type_bridge.Compile(object);
+				if (compiled.evaluateResult) compiled.evaluateResult.code = void 0;
+				if (compiled.buildResult) compiled.buildResult.functions = void 0;
+				check = (v) => compiled.Check(v);
+			} catch {
+				check = (v) => require_type_bridge.Check(object, v);
+			}
+			if (!check(next)) return false;
+			if (value.length <= MEMO_LIMIT) {
+				raw = value;
+				parsed = next;
+			}
+			return true;
 		} catch {
 			return false;
 		}
-	}, () => "must be an object"), (value) => require_type_bridge.Decode(object, JSON.parse(value)));
+	}, () => "must be an object"), (value) => {
+		const decoded = value === raw ? parsed : JSON.parse(value);
+		raw = void 0;
+		parsed = void 0;
+		return require_type_bridge.Decode(object, decoded);
+	});
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ObjectString, require_type_elysia_union.Union([object, objectString], meta));
 }
 

package/dist/type/elysia/object-string.mjs

@@ -1,5 +1,5 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Decode as Decode$1 } from "../bridge.mjs";
+import { Check, Compile, Decode as Decode$1 } from "../bridge.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
@@ -8,17 +8,41 @@ import { ObjectType } from "./object.mjs";
 import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/object-string.ts
+const MEMO_LIMIT = 8192;
 function ObjectString(property, _options) {
 	const [{ properties, ...constraints }, meta] = getMeta(_options ?? nullObject());
 	const object = ObjectType(property, constraints);
+	let check;
+	let raw;
+	let parsed;
 	const objectString = Decode(Refine(StringType(), (value) => {
 		if (value.charCodeAt(0) !== 123) return false;
+		if (value === raw) return true;
 		try {
-			return Check(object, JSON.parse(value));
+			const next = JSON.parse(value);
+			if (!check) try {
+				const compiled = Compile(object);
+				if (compiled.evaluateResult) compiled.evaluateResult.code = void 0;
+				if (compiled.buildResult) compiled.buildResult.functions = void 0;
+				check = (v) => compiled.Check(v);
+			} catch {
+				check = (v) => Check(object, v);
+			}
+			if (!check(next)) return false;
+			if (value.length <= MEMO_LIMIT) {
+				raw = value;
+				parsed = next;
+			}
+			return true;
 		} catch {
 			return false;
 		}
-	}, () => "must be an object"), (value) => Decode$1(object, JSON.parse(value)));
+	}, () => "must be an object"), (value) => {
+		const decoded = value === raw ? parsed : JSON.parse(value);
+		raw = void 0;
+		parsed = void 0;
+		return Decode$1(object, decoded);
+	});
 	return elyType(ELYSIA_TYPES.ObjectString, Union([object, objectString], meta));
 }
 

package/dist/type/validator/index.js

@@ -516,17 +516,15 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		}
 	}
 	#markForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && !("~ely-form" in value)) {
-			Object.defineProperty(value, "~ely-form", {
-				value: 1,
-				configurable: true
-			});
-			return true;
+		if (this.#isForm && value !== null && typeof value === "object") {
+			const previous = Object.getPrototypeOf(value);
+			if (previous === require_utils.ELYSIA_FORM_PROTOTYPE) return;
+			Object.setPrototypeOf(value, require_utils.ELYSIA_FORM_PROTOTYPE);
+			return previous;
 		}
-		return false;
 	}
-	#unmarkForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && "~ely-form" in value && Object.getOwnPropertyDescriptor(value, "~ely-form")?.configurable) delete value["~ely-form"];
+	#unmarkForm(value, previous) {
+		if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === require_utils.ELYSIA_FORM_PROTOTYPE) Object.setPrototypeOf(value, previous);
 	}
 	From(value, type) {
 		return this.isAsync ? this.FromAsync(value, type) : this.FromSync(value, type);
@@ -568,7 +566,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 			if (bypass) return bypass.value;
 		}
 		const markedValue = value;
-		const marked = this.#isForm ? this.#markForm(value) : false;
+		const marked = this.#isForm ? this.#markForm(value) : void 0;
 		try {
 			if (this.hasCodec) {
 				if (!this.#noValidate) {
@@ -607,7 +605,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 			if (this.Clean && !this.#decodeMirror && !this.#cleanRedundant) value = this.Clean(value);
 			return value;
 		} finally {
-			if (marked) this.#unmarkForm(markedValue);
+			if (marked !== void 0) this.#unmarkForm(markedValue, marked);
 		}
 	}
 	FromSync(value, type) {
@@ -623,7 +621,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 			if (bypass) return bypass.value;
 		}
 		const markedValue = value;
-		const marked = this.#isForm ? this.#markForm(value) : false;
+		const marked = this.#isForm ? this.#markForm(value) : void 0;
 		try {
 			if (this.hasCodec) {
 				const errors = this.#noValidate ? void 0 : this.#validate(value);
@@ -644,7 +642,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 			if (this.Clean && !this.#decodeMirror && !this.#cleanRedundant) value = this.Clean(value);
 			return value;
 		} finally {
-			if (marked) this.#unmarkForm(markedValue);
+			if (marked !== void 0) this.#unmarkForm(markedValue, marked);
 		}
 	}
 };

package/dist/type/validator/index.mjs

@@ -1,4 +1,4 @@
-import { nullObject } from "../../utils.mjs";
+import { ELYSIA_FORM_PROTOTYPE, nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { ValidationError } from "../../error.mjs";
 import { Capture, Compiled, EMPTY_EXTERNALS, captureImpl, reconstruct } from "../../compile/aot.mjs";
@@ -514,17 +514,15 @@ var TypeBoxValidator = class extends Validator$1 {
 		}
 	}
 	#markForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && !("~ely-form" in value)) {
-			Object.defineProperty(value, "~ely-form", {
-				value: 1,
-				configurable: true
-			});
-			return true;
+		if (this.#isForm && value !== null && typeof value === "object") {
+			const previous = Object.getPrototypeOf(value);
+			if (previous === ELYSIA_FORM_PROTOTYPE) return;
+			Object.setPrototypeOf(value, ELYSIA_FORM_PROTOTYPE);
+			return previous;
 		}
-		return false;
 	}
-	#unmarkForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && "~ely-form" in value && Object.getOwnPropertyDescriptor(value, "~ely-form")?.configurable) delete value["~ely-form"];
+	#unmarkForm(value, previous) {
+		if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === ELYSIA_FORM_PROTOTYPE) Object.setPrototypeOf(value, previous);
 	}
 	From(value, type) {
 		return this.isAsync ? this.FromAsync(value, type) : this.FromSync(value, type);
@@ -566,7 +564,7 @@ var TypeBoxValidator = class extends Validator$1 {
 			if (bypass) return bypass.value;
 		}
 		const markedValue = value;
-		const marked = this.#isForm ? this.#markForm(value) : false;
+		const marked = this.#isForm ? this.#markForm(value) : void 0;
 		try {
 			if (this.hasCodec) {
 				if (!this.#noValidate) {
@@ -605,7 +603,7 @@ var TypeBoxValidator = class extends Validator$1 {
 			if (this.Clean && !this.#decodeMirror && !this.#cleanRedundant) value = this.Clean(value);
 			return value;
 		} finally {
-			if (marked) this.#unmarkForm(markedValue);
+			if (marked !== void 0) this.#unmarkForm(markedValue, marked);
 		}
 	}
 	FromSync(value, type) {
@@ -621,7 +619,7 @@ var TypeBoxValidator = class extends Validator$1 {
 			if (bypass) return bypass.value;
 		}
 		const markedValue = value;
-		const marked = this.#isForm ? this.#markForm(value) : false;
+		const marked = this.#isForm ? this.#markForm(value) : void 0;
 		try {
 			if (this.hasCodec) {
 				const errors = this.#noValidate ? void 0 : this.#validate(value);
@@ -642,7 +640,7 @@ var TypeBoxValidator = class extends Validator$1 {
 			if (this.Clean && !this.#decodeMirror && !this.#cleanRedundant) value = this.Clean(value);
 			return value;
 		} finally {
-			if (marked) this.#unmarkForm(markedValue);
+			if (marked !== void 0) this.#unmarkForm(markedValue, marked);
 		}
 	}
 };

package/dist/types.d.ts

@@ -1,10 +1,10 @@
 import { CookieOptions } from "./cookie/types.js";
-import { StatusMapBack } from "./constants.js";
-import { ElysiaError, ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
 import { ElysiaFile } from "./universal/file.js";
+import { StatusMap, StatusMapBack } from "./constants.js";
 import { Serve } from "./universal/server.js";
 import { ChainNode } from "./utils.js";
+import { ElysiaError, ElysiaStatus, ProblemResponseBody } from "./error.js";
 import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.js";
 import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { AnyElysia, Elysia } from "./base.js";
@@ -620,9 +620,7 @@ type StaticCyclic<T extends TypeBoxSchema, Definitions extends Record<string, An
 type UnwrapSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends undefined ? unknown : Schema extends TypeBoxSchema ? Schema extends OptionalField ? Partial<StaticCyclic<Schema, Definitions>> : StaticCyclic<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['output'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['output'] : unknown : unknown : unknown;
 type UnwrapBodySchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = undefined extends Schema ? unknown : Schema extends TypeBoxSchema ? Schema extends OptionalField ? Partial<StaticCyclic<Schema, Definitions>> | null : StaticCyclic<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['output'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['output'] : unknown : unknown : unknown;
 type FormInnerProperties<Schema> = Extract<Schema extends TIntersect<infer Members> ? Members[number] : never, TObject>['properties'];
-type UnwrapResponseSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends TypeBoxSchema ? StaticEncode<Schema> extends {
-  '~ely-form': any;
-} ? ElysiaFormData<{ [K in keyof FormInnerProperties<Schema>]: Static<FormInnerProperties<Schema>[K] & TSchema> }> : UnwrapSchema<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['input'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['input'] : unknown : unknown : unknown;
+type UnwrapResponseSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends TypeBoxSchema ? StaticEncode<Schema> extends ElysiaFormData<any> ? ElysiaFormData<{ [K in keyof FormInnerProperties<Schema>]: Static<FormInnerProperties<Schema>[K] & TSchema> }> : UnwrapSchema<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['input'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['input'] : unknown : unknown : unknown;
 interface UnwrapRoute<in out Schema extends InputSchema<any>, in out Definitions extends DefinitionBase['typebox'] = {}, in out Path extends string = ''> {
   body: UnwrapBodySchema<Schema['body'], Definitions>;
   headers: UnwrapSchema<Schema['headers'], Definitions>;
@@ -744,19 +742,102 @@ type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema exte
 }, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
 type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' | '/' ? Property : _CreateEden<Path, Property>;
 type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? { [x in Start]: _CreateEden<Rest, Property> } : Path extends '' ? Property : { [x in Path]: Property };
+/**
+ * Value an annotation knob resolves to, `never` when it annotates nothing.
+ *
+ * Both knobs are canonically methods, so what they *return* is the
+ * annotation. A value or getter reads as the value itself. An `unknown`
+ * declaration claims nothing, and `undefined` is excluded — it falls through
+ * to the next tier rather than being served
+ */
+type ResolveAnnotation<V> = (V extends ((...args: any) => infer Returned) ? Returned : V) extends infer Value ? Exclude<Awaited<Value>, undefined> extends infer Resolved ? IsNever<Resolved> extends true ? never : unknown extends Resolved ? never : Resolved : never : never;
+/** Whether a knob may resolve `undefined` and fall through to the next tier */
+type AnnotationFallsThrough<V> = undefined extends Awaited<V extends ((...args: any) => infer Returned) ? Returned : V> ? true : false;
+/**
+ * Numeric literal `status` an error annotates, written as a number or a
+ * status name. `never` when it's absent or widened
+ */
+type LiteralErrorStatus<E> = E extends {
+  status: infer S;
+} ? number extends S ? never : keyof StatusMap extends S ? never : S extends keyof StatusMap ? StatusMap[S] : S extends number ? S : never : never;
+/**
+ * An owned `HTTPError` carries a *literal* `type`. Wild errors often carry a
+ * wide-string one (`ErrorEvent.type`, SDK errors), which claims nothing
+ */
+type OwnedError<E> = E extends {
+  type: infer T extends string;
+} ? string extends T ? false : true : false;
+/**
+ * RFC 9457 problem type an error contributes. `problemBody` defaults an
+ * absent one to `'about:blank'`
+ */
+type ErrorProblemType<E> = OwnedError<E> extends true ? E extends {
+  type: infer T extends string;
+} ? T : 'about:blank' : 'about:blank';
+/**
+ * Problem document served for a `detail` annotation. `detail` is carried
+ * verbatim, objects included — it is never spread into the envelope
+ */
+type ProblemOf<E, Detail> = ProblemResponseBody<ErrorFallbackStatus<E>, {
+  type: ErrorProblemType<E>;
+  detail: Detail;
+}>;
+/**
+ * Tier 3 — nothing annotated. An error that claimed a problem serves its
+ * message as `detail`, anything else keeps the legacy raw lane
+ */
+type MessageTier<E> = OwnedError<E> extends true ? ProblemOf<E, string> : E extends {
+  response: infer R;
+} ? unknown extends R ? string : R : string;
+/** Tier 2 — `detail` fills the `detail` member of a problem document */
+type DetailTier<E> = E extends {
+  detail: infer V;
+} ? [OwnedError<E>, V] extends [false, (...args: any) => any] ? MessageTier<E> : IsNever<ResolveAnnotation<V>> extends true ? MessageTier<E> : AnnotationFallsThrough<V> extends true ? ProblemOf<E, ResolveAnnotation<V>> | MessageTier<E> : ProblemOf<E, ResolveAnnotation<V>> : MessageTier<E>;
+/**
+ * Tier 1 — `value` replaces the whole response, so it is served raw: no
+ * envelope, no problem+json
+ */
+type ValueTier<E> = E extends {
+  value: infer V;
+} ? [OwnedError<E>, V] extends [false, (...args: any) => any] ? DetailTier<E> : IsNever<ResolveAnnotation<V>> extends true ? DetailTier<E> : AnnotationFallsThrough<V> extends true ? ResolveAnnotation<V> | DetailTier<E> : ResolveAnnotation<V> : DetailTier<E>;
+/**
+ * Key a served value by the status it actually reaches.
+ *
+ * `value()` may hand back a `status()` or `problem()`, which the mapResponse
+ * lane serves at the status *it* carries, not the one the error annotated —
+ * so those members escape to their own keys. Everything else stays under
+ * `Fallback`. The unwrapping is `MergeResponseStatus`, the same one a route
+ * handler's returned `status()` goes through
+ */
+type ServedAtStatus<Served, Fallback extends number> = UnionResponseStatus<IsNever<Extract<Served, AnyElysiaStatus>> extends true ? {} : MergeResponseStatus<Extract<Served, AnyElysiaStatus>>, Exclude<Served, AnyElysiaStatus> extends infer Plain ? IsNever<Plain> extends true ? {} : { [Status in Fallback]: Plain } : {}>;
+/**
+ * Response an error describes for itself, resolved through the three tiers:
+ * a raw `value`, else a problem document built from `detail`, else its message
+ */
+type SelfDescribedResponse<E> = ServedAtStatus<ValueTier<E>, ErrorFallbackStatus<E>>;
+/**
+ * Response of an error that reached the error pipeline without a matching
+ * `.error(Class, handler)`.
+ *
+ * A self-describing error maps to its annotated `status` and knobs,
+ * anything else is served as an unhandled 500
+ */
+type UnhandledErrorResponse<E> = [E] extends [never] ? {} : MergeStatusUnion<E extends unknown ? OwnedError<E> extends true ? SelfDescribedResponse<E> : IsNever<LiteralErrorStatus<E>> extends true ? {
+  500: E;
+} : SelfDescribedResponse<E> : never>;
 type CreateEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse, Err extends Error = never> = RouteSchema extends MacroContext ? {
   body: Schema['body'];
   params: IsNever<keyof Schema['params']> extends true ? ResolvePath<Path> : Schema['params'];
   query: Schema['query'];
   headers: Schema['headers'];
-  response: Prettify<Res>;
+  response: Prettify<UnionResponseStatus<Res, UnhandledErrorResponse<Err>>>;
   error: Err;
 } : {
   body: Prettify<Schema['body'] & MacroContext['body']>;
   params: IsNever<keyof (Schema['params'] & MacroContext['params'])> extends true ? ResolvePath<Path> : Prettify<Schema['params'] & MacroContext['params']>;
   query: Prettify<Schema['query'] & MacroContext['query']>;
   headers: Prettify<Schema['headers'] & MacroContext['headers']>;
-  response: Prettify<Res>;
+  response: Prettify<UnionResponseStatus<Res, UnhandledErrorResponse<Err>>>;
   error: Err;
 };
 type CreateWSEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse> = Omit<CreateEdenResponse<Path, Schema, MacroContext, Res>, 'error'>;
@@ -788,16 +869,13 @@ type ExtractErrorFromHandle<in out Handle> = { [ErrorResponse in Extract<Handle,
  * Status used when an error handler returns a plain value (or falls through):
  * the error's declared literal `status`, otherwise 500
  */
-type ErrorFallbackStatus<E> = E extends {
-  status: infer S extends number;
-} ? number extends S ? 500 : S : 500;
+type ErrorFallbackStatus<E> = IsNever<LiteralErrorStatus<E>> extends true ? 500 : LiteralErrorStatus<E>;
 /**
- * Body produced when no error handler returns a value:
- * the error's declared `response`, otherwise its message (string)
+ * Body produced when no error handler returns a value. Falling through lands
+ * on exactly the lane an unhandled error takes, so it resolves the same three
+ * tiers — `MessageTier` already carries the foreign `response` fallback
  */
-type ErrorFallbackBody<E> = E extends {
-  response: infer R;
-} ? unknown extends R ? string : R : string;
+type ErrorFallbackBody<E> = ValueTier<E>;
 /**
  * `Definitions['error']` / `EphemeralType['error']` entry registered by an
  * `.error(Class, handler)` call
@@ -806,11 +884,19 @@ type ErrorDefinitionEntry<E extends abstract new (...args: any) => Error, R> = {
   error: InstanceType<E>;
   response: ErrorHandlerResponseSchema<Awaited<R>, InstanceType<E>>;
 };
-type ErrorHandlerResponseSchema<R, E> = ExtractErrorFromHandle<Exclude<R, Error>> & (Exclude<R, Extract<Exclude<R, Error>, AnyElysiaStatus> | undefined> | (undefined extends R ? ErrorFallbackBody<E> : never) extends infer Plain ? IsNever<Plain> extends true ? {} : { [S in ErrorFallbackStatus<E>]: Plain } : {});
-type MatchRegisteredError<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? [V] extends [Head['error']] ? Head['response'] : MatchRegisteredError<V, Rest> : never;
+type ErrorHandlerResponseSchema<R, E> = ExtractErrorFromHandle<Exclude<R, Error>> & (Exclude<R, Extract<Exclude<R, Error>, AnyElysiaStatus> | undefined> | (undefined extends R ? ErrorFallbackBody<E> : never) extends infer Served ? ServedAtStatus<Served, ErrorFallbackStatus<E>> : {});
+type MatchRegisteredError<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? V extends Head['error'] ? Head['response'] : MatchRegisteredError<V, Rest> : never;
 type HasErrorMatch<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? [V] extends [Head['error']] ? true : HasErrorMatch<V, Rest> : false;
 type UnhandledReturnedError<Value, Errors extends ErrorDefinition[]> = 0 extends 1 & Value ? never : Extract<Value, Error> extends infer Es ? Es extends Error ? HasErrorMatch<Es, Errors> extends true ? never : Es : never : never;
 type UnhandledReturnedErrorOf<T, Errors extends ErrorDefinition[]> = T extends ((...a: any) => MaybePromise<infer R>) ? UnhandledReturnedError<R, Errors> : UnhandledReturnedError<T, Errors>;
+/**
+ * Strip what `UnhandledErrorResponse` contributed for `Err` from a route's
+ * response, so a now-handled error doesn't leave a stale status behind.
+ *
+ * A response that merely shares the same status survives, unless it's
+ * indistinguishable from the error's own body
+ */
+type WithoutUnhandledErrorResponse<Response, Err> = UnhandledErrorResponse<Err> extends infer Contributed ? { [K in keyof Response as K extends keyof Contributed ? IsNever<Exclude<Response[K], Contributed[K]>> extends true ? never : K : K]: K extends keyof Contributed ? Exclude<Response[K], Contributed[K]> : Response[K] } : never;
 type ResolveRouteErrors<Routes, Errors extends ErrorDefinition[]> = Errors extends [] ? Routes : { [K in keyof Routes]: Routes[K] extends {
   params: any;
   query: any;
@@ -818,7 +904,7 @@ type ResolveRouteErrors<Routes, Errors extends ErrorDefinition[]> = Errors exten
   response: any;
   error: any;
 } ? [Routes[K]['error']] extends [never] ? Routes[K] : Omit<Routes[K], 'response' | 'error'> & {
-  response: Prettify<UnionResponseStatus<Routes[K]['response'], ExtractReturnedError<Routes[K]['error'], Errors>>>;
+  response: Prettify<UnionResponseStatus<WithoutUnhandledErrorResponse<Routes[K]['response'], Routes[K]['error']>, UnionResponseStatus<ExtractReturnedError<Routes[K]['error'], Errors>, UnhandledErrorResponse<UnhandledReturnedError<Routes[K]['error'], Errors>>>>>;
   error: UnhandledReturnedError<Routes[K]['error'], Errors>;
 } : Routes[K] extends Record<keyof any, any> ? ResolveRouteErrors<Routes[K], Errors> : Routes[K] };
 type MergeStatusUnion<U> = { [K in U extends unknown ? keyof U : never]: U extends unknown ? K extends keyof U ? U[K] : never : never };

package/dist/universal/file.js

@@ -110,6 +110,7 @@ var ElysiaFile = class {
 		return value ?? 0;
 	}
 };
+Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 
 //#endregion
 exports.ElysiaFile = ElysiaFile;

package/dist/universal/file.mjs

@@ -109,6 +109,7 @@ var ElysiaFile = class {
 		return value ?? 0;
 	}
 };
+Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 
 //#endregion
 export { ElysiaFile, file, getFileExtension, mime };

package/dist/universal/index.d.ts

@@ -1,5 +1,5 @@
-import { isProduction } from "./is-production.js";
 import { file } from "./file.js";
 import { env } from "./env.js";
 import { ErrorLike, GenericServeOptions, ListenCallback, Serve, ServeOptions, Server, ServerWebSocketSendStatus, SocketAddress } from "./server.js";
+import { isProduction } from "./is-production.js";
 export { type ErrorLike, type GenericServeOptions, type ListenCallback, type Serve, type ServeOptions, type Server, type ServerWebSocketSendStatus, type SocketAddress, env, file, isProduction };

package/dist/utils.d.ts

@@ -97,10 +97,8 @@ declare function flattenChainMemoReadonly(root: object, start: ChainNode | undef
  */
 declare const redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response;
 type redirect = typeof redirect;
-/**
- * Build `FormData` from a `form()` object, skipping the internal `~ely-form`
- * marker that flags the object as a form.
- */
+declare const ELYSIA_FORM_PROTOTYPE: object;
+declare const isElysiaForm: (value: unknown) => boolean;
 declare function formToFormData(value: Record<keyof any, unknown>): FormData;
 /**
  * Return a `multipart/form-data` response.
@@ -177,4 +175,4 @@ declare namespace prefix {
 }
 declare function serializeMacroSeed(_key: string, value: unknown): unknown;
 //#endregion
-export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };
+export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isElysiaForm, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/utils.js

@@ -251,6 +251,10 @@ const redirect = (url, status = 302) => new Response(null, {
 	status,
 	headers: { location: notLatin.test(url) ? encodeURI(url) : url }
 });
+var ElysiaForm = class {};
+Object.defineProperty(ElysiaForm, "name", { value: "ElysiaForm" });
+const ELYSIA_FORM_PROTOTYPE = ElysiaForm.prototype;
+const isElysiaForm = (value) => value instanceof ElysiaForm || value != null && Object.getPrototypeOf(value)?.constructor?.name === "ElysiaForm";
 function appendFormField(formData, key, value) {
 	if (value === void 0 || value === null) return;
 	if (value instanceof Blob) formData.append(key, value);
@@ -258,14 +262,9 @@ function appendFormField(formData, key, value) {
 	else if (typeof value === "object") formData.append(key, JSON.stringify(value));
 	else formData.append(key, "" + value);
 }
-/**
-* Build `FormData` from a `form()` object, skipping the internal `~ely-form`
-* marker that flags the object as a form.
-*/
 function formToFormData(value) {
 	const formData = new FormData();
 	for (const key in value) {
-		if (key === "~ely-form") continue;
 		const field = value[key];
 		if (Array.isArray(field)) for (const item of field) appendFormField(formData, key, item);
 		else appendFormField(formData, key, field);
@@ -287,10 +286,7 @@ function formToFormData(value) {
 * )
 * ```
 */
-const form = (value) => ({
-	...value,
-	"~ely-form": 1
-});
+const form = (value) => Object.setPrototypeOf({ ...value }, ELYSIA_FORM_PROTOTYPE);
 const getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, -1) : path + "/";
 const byteStreams = /* @__PURE__ */ new WeakSet();
 /**
@@ -685,6 +681,7 @@ function serializeMacroSeed(_key, value) {
 }
 
 //#endregion
+exports.ELYSIA_FORM_PROTOTYPE = ELYSIA_FORM_PROTOTYPE;
 exports.bytes = bytes;
 exports.clearFlattenChainMemo = clearFlattenChainMemo;
 exports.cloneHook = cloneHook;
@@ -712,6 +709,7 @@ exports.invalidateMacroEpoch = invalidateMacroEpoch;
 exports.isBlob = isBlob;
 exports.isByteStream = isByteStream;
 exports.isCompactBeforeHandleOnly = isCompactBeforeHandleOnly;
+exports.isElysiaForm = isElysiaForm;
 exports.isEmpty = isEmpty;
 exports.isLocalScope = isLocalScope;
 exports.isMapDeriveEntry = isMapDeriveEntry;

package/dist/utils.mjs

@@ -250,6 +250,10 @@ const redirect = (url, status = 302) => new Response(null, {
 	status,
 	headers: { location: notLatin.test(url) ? encodeURI(url) : url }
 });
+var ElysiaForm = class {};
+Object.defineProperty(ElysiaForm, "name", { value: "ElysiaForm" });
+const ELYSIA_FORM_PROTOTYPE = ElysiaForm.prototype;
+const isElysiaForm = (value) => value instanceof ElysiaForm || value != null && Object.getPrototypeOf(value)?.constructor?.name === "ElysiaForm";
 function appendFormField(formData, key, value) {
 	if (value === void 0 || value === null) return;
 	if (value instanceof Blob) formData.append(key, value);
@@ -257,14 +261,9 @@ function appendFormField(formData, key, value) {
 	else if (typeof value === "object") formData.append(key, JSON.stringify(value));
 	else formData.append(key, "" + value);
 }
-/**
-* Build `FormData` from a `form()` object, skipping the internal `~ely-form`
-* marker that flags the object as a form.
-*/
 function formToFormData(value) {
 	const formData = new FormData();
 	for (const key in value) {
-		if (key === "~ely-form") continue;
 		const field = value[key];
 		if (Array.isArray(field)) for (const item of field) appendFormField(formData, key, item);
 		else appendFormField(formData, key, field);
@@ -286,10 +285,7 @@ function formToFormData(value) {
 * )
 * ```
 */
-const form = (value) => ({
-	...value,
-	"~ely-form": 1
-});
+const form = (value) => Object.setPrototypeOf({ ...value }, ELYSIA_FORM_PROTOTYPE);
 const getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, -1) : path + "/";
 const byteStreams = /* @__PURE__ */ new WeakSet();
 /**
@@ -684,4 +680,4 @@ function serializeMacroSeed(_key, value) {
 }
 
 //#endregion
-export { bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };
+export { ELYSIA_FORM_PROTOTYPE, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isElysiaForm, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/ws/route.js

@@ -7,12 +7,12 @@ const require_error = require('../error.js');
 const require_adapter_web_standard_handler = require('../adapter/web-standard/handler.js');
 const require_parse_query = require('../parse-query.js');
 const require_generation = require('../generation.js');
+const require_handler_error = require('../handler/error.js');
 const require_compile_handler_utils = require('../compile/handler/utils.js');
 const require_validator_index = require('../validator/index.js');
 const require_validator_route = require('../validator/route.js');
 const require_compile_handler_frozen_validator = require('../compile/handler/frozen-validator.js');
 const require_compile_handler_index = require('../compile/handler/index.js');
-const require_handler_error = require('../handler/error.js');
 const require_ws_context = require('./context.js');
 const require_ws_parser = require('./parser.js');
 

package/dist/ws/route.mjs

@@ -6,12 +6,12 @@ import { ElysiaError, ElysiaStatus, ValidationError, internalServerErrorBodyStri
 import { mapResponse } from "../adapter/web-standard/handler.mjs";
 import { parseQueryFromURL } from "../parse-query.mjs";
 import { frozenRootOf } from "../generation.mjs";
+import { createErrorHandler } from "../handler/error.mjs";
 import { deriveModes, getQueryParseChannels, replaceDeriveContext } from "../compile/handler/utils.mjs";
 import { StandardValidator } from "../validator/index.mjs";
 import { RouteValidator } from "../validator/route.mjs";
 import { buildFrozenRouteValidator, isBridgeNotInitialized } from "../compile/handler/frozen-validator.mjs";
 import { composeRouteHook, localMacroRoot, resolveWSLocalHook } from "../compile/handler/index.mjs";
-import { createErrorHandler } from "../handler/error.mjs";
 import { ElysiaWS, isGeneratorObject } from "./context.mjs";
 import { createMessageParser } from "./parser.mjs";
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-beta.1",
+	"version": "2.0.0-beta.2",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",
@@ -255,7 +255,7 @@
 		"esbuild": "0.25.4",
 		"eslint": "^9.24.0",
 		"eslint-plugin-sonarjs": "^4.0.2",
-		"exact-mirror": "1.2.2",
+		"exact-mirror": "^1.2.4",
 		"expect-type": "^1.2.1",
 		"file-type": "^22.0.0",
 		"globals": "^17.4.0",