elysia 2.0.0-beta.21 → 2.0.0-beta.22

package/dist/utils.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { isBun } from "./universal/constants.mjs";
 import { dangerousKeys } from "./constants.mjs";
 import { ElysiaFile } from "./universal/file.mjs";
@@ -7,6 +8,27 @@ const nullObject = () => Object.create(null);
 const mapDeriveEntry = (fn) => [fn, "mapDerive"];
 const deriveEntryFn = (entry) => Array.isArray(entry) ? entry[0] : entry;
 const isMapDeriveEntry = (entry) => Array.isArray(entry) && entry[1] === "mapDerive";
+const isPlainDeriveEntry = (entry) => Array.isArray(entry) && entry[1] === "beforeHandle";
+/**
+* `~deriveEntries` for `hooks` whose role per occurrence is `at` (an entry
+* for a derive, undefined for a plain hook). `deriveModes` gives each
+* function's entries to its occurrences in order, so a plain occurrence
+* before a derive of the same function gets a placeholder
+*/
+function occurrenceDeriveEntries(hooks, at) {
+	const derived = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (let i = hooks.length; i--;) {
+		const entry = at[i];
+		if (entry !== void 0) {
+			entries.push(entry);
+			derived.add(hooks[i]);
+		} else if (derived.has(hooks[i])) entries.push([hooks[i], "beforeHandle"]);
+	}
+	return entries.reverse();
+}
+/** Each function's derive entries, in occurrence order */
+const deriveQueues = (entries) => entries && Map.groupBy(entries, deriveEntryFn);
 function isEmpty(obj) {
 	for (const _ in obj) return false;
 	return true;
@@ -36,6 +58,20 @@ function fnv1a(str) {
 	}
 	return hash >>> 0;
 }
+/**
+* 48-bit hash of a named plugin's key (fnv1a + 16 bits of a second hash): at
+* 32 bits two plugins collide by ~77k and the second is dropped. 48 keeps
+* `origin * 16 + slot` exact
+*/
+function pluginHash(str) {
+	let mix = 2654435769;
+	const len = str.length;
+	for (let i = 0; i < len; i++) {
+		mix = Math.imul(mix ^ str.charCodeAt(i), 1540483477);
+		mix ^= mix >>> 15;
+	}
+	return (mix >>> 16) * 4294967296 + fnv1a(str);
+}
 const compositionKeys = Object.freeze([
 	"allOf",
 	"anyOf",
@@ -57,24 +93,27 @@ function refTargets(roots, models = {}) {
 	roots.concat(Object.values(models)).forEach(index);
 	return (name) => targets[name] ?? [];
 }
+const macroOrigin = /* @__PURE__ */ new WeakMap();
 /**
-* Maps each lifecycle/derive function to the hash of the named plugin it was
-* first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
-* origin is already in `parent.#apps`, the parent has already absorbed that
-* named plugin via another path and should skip re-adding the fn.
-*
-* Anonymous plugins (no name) don't tag their fns - there's no hash to dedup
-* by, so their fns always propagate.
+* Id of `ref` in the registry at `globalThis[key]`, `next` being the last id
+* handed out. Weak so it doesn't retain `ref`, realm-wide so every installed
+* Elysia copy agrees
 */
-const fnOrigin = /* @__PURE__ */ new WeakMap();
-const macroOrigin = /* @__PURE__ */ new WeakMap();
-const isLocalScope = (s) => s === "local" || s === void 0;
+function realmId(key, ref) {
+	const realm = globalThis;
+	const registry = realm[key] ??= {
+		ids: /* @__PURE__ */ new WeakMap(),
+		next: 0
+	};
+	let id = registry.ids.get(ref);
+	if (id === void 0) registry.ids.set(ref, id = ++registry.next);
+	return id;
+}
 /**
-* The absorbing instance's chain as it stood at `.use()`: the `over` of a
-* combine node, or the node itself. A combine node is never on an instance's
-* own chain, so it can't serve as a `stopAt` directly
+* Id of an unnamed plugin in `childrenHash`, negative so it never collides
+* with a named plugin's unsigned hash
 */
-const rootSnapshot = (node) => node && "combine" in node ? node.over : node;
+const pluginId = (plugin) => -realmId("~elysiaPluginIds", plugin);
 const COMPACT_CHUNK_SIZE = 32;
 const emptyCompactBeforeHandlePrefix = {
 	length: 0,
@@ -157,14 +196,21 @@ function compactBeforeHandlePrefix(start) {
 }
 const flattenNodeStack = [];
 const flattenPhaseStack = [];
+const deriveSlot = 15;
+const withLayer = (outer, layer) => new Set([...outer ?? [], ...layer]);
 /**
 * Walk the chain tail-first into a fresh `Partial<AppHook>`
 *
+* Each instance chain a combine node links is one layer, outermost first.
+* A named plugin's hook is skipped when an outer layer, or `skip`, already
+* installed that plugin's same lifecycle event: it runs once, at its
+* outermost position. Within a layer every registration stays
+*
 * Explicit-stack walk (no recursion) so it works uniformly for linear
 * chains and combine nodes without risking stack overflow on deep chains
 */
-function flattenChain(start, keep, stopAt, resolveAdded) {
-	if (!start || start === stopAt) return;
+function flattenChain(start, resolveAdded, skip, info) {
+	if (!start) return;
 	const result = nullObject();
 	const nodes = flattenNodeStack;
 	const phases = flattenPhaseStack;
@@ -172,47 +218,79 @@ function flattenChain(start, keep, stopAt, resolveAdded) {
 	phases.length = 0;
 	nodes.push(start);
 	phases.push(0);
+	let outer = skip;
+	let layer;
+	let roles;
 	while (nodes.length) {
 		const node = nodes.pop();
-		if (phases.pop() === 1) {
+		const phase = phases.pop();
+		if (phase === 2) {
+			if (layer?.length) {
+				outer = withLayer(outer, layer);
+				layer.length = 0;
+			}
+			continue;
+		}
+		if (phase === 1) {
+			const { origin, propagated, scope } = node;
+			if (info && origin !== void 0) info.named = true;
 			const added = resolveAdded ? resolveAdded(node) : node.added;
-			if (added) {
-				const nodeScope = node.scope;
-				if (!(keep && !keep(nodeScope))) for (const key in added) {
-					const v = added[key];
-					if (v === void 0 || v === null) continue;
-					if (eventProperties.has(key) || key === "schemas" || key === "~deriveEntries") {
-						const existing = result[key];
-						if (Array.isArray(v)) if (existing) {
-							const arr = existing;
-							for (let i = 0; i < v.length; i++) arr.push(v[i]);
-						} else result[key] = v.slice();
-						else if (existing) existing.push(v);
-						else result[key] = [v];
-					} else result[key] = v;
+			const base = origin !== void 0 && (propagated || scope === "plugin" || scope === "global") ? origin * 16 : void 0;
+			const derives = deriveQueues(added?.["~deriveEntries"]);
+			if (added) for (const key in added) {
+				const v = added[key];
+				if (v == null || key === "~deriveEntries") continue;
+				const slot = lifecycleEvents.indexOf(key);
+				if (key === "beforeHandle") {
+					for (const fn of Array.isArray(v) ? v : [v]) {
+						const entry = derives?.get(fn)?.shift();
+						if (base !== void 0) {
+							const pair = base + (entry === void 0 ? slot : deriveSlot);
+							if (outer?.has(pair)) continue;
+							(layer ??= []).push(pair);
+						}
+						const list = result.beforeHandle ??= [];
+						if (entry !== void 0) (roles ??= [])[list.length] = entry;
+						list.push(fn);
+					}
+					continue;
 				}
+				if (base !== void 0 && slot !== -1) {
+					if (outer?.has(base + slot)) continue;
+					if (!Array.isArray(v) || v.length) (layer ??= []).push(base + slot);
+				}
+				if (slot !== -1 || key === "schemas") {
+					const existing = result[key];
+					if (Array.isArray(v)) if (existing) for (let i = 0; i < v.length; i++) existing.push(v[i]);
+					else result[key] = v.slice();
+					else if (existing) existing.push(v);
+					else result[key] = [v];
+				} else result[key] = v;
 			}
 			continue;
 		}
-		if (stopAt && node === stopAt) continue;
 		if ("combine" in node) {
 			if (node.combine) {
 				nodes.push(node.combine);
 				phases.push(0);
 			}
 			if (node.over) {
+				nodes.push(node);
+				phases.push(2);
 				nodes.push(node.over);
 				phases.push(0);
 			}
 		} else {
 			nodes.push(node);
 			phases.push(1);
-			if (node.parent && node.parent !== stopAt) {
+			if (node.parent) {
 				nodes.push(node.parent);
 				phases.push(0);
 			}
 		}
 	}
+	if (info) info.installs = layer?.length ? withLayer(outer, layer) : outer;
+	if (roles) result["~deriveEntries"] = occurrenceDeriveEntries(result.beforeHandle, roles);
 	if (isNotEmpty(result)) return result;
 }
 /**
@@ -233,27 +311,45 @@ function clearFlattenChainMemo(root) {
 	flattenChainMemos.delete(root);
 }
 const emptyFlatten = Object.freeze(nullObject());
-function flattenChainMemoReadonly(root, start, resolveAdded) {
-	if (!start) return;
+function flattenMemoOf(root) {
 	let bucket = flattenChainMemos.get(root);
 	if (!bucket || bucket.e !== macroTableEpoch) {
 		bucket = {
 			e: macroTableEpoch,
-			per: /* @__PURE__ */ new WeakMap()
+			per: /* @__PURE__ */ new WeakMap(),
+			info: /* @__PURE__ */ new WeakMap()
 		};
 		flattenChainMemos.set(root, bucket);
 	}
-	const perRoot = bucket.per;
-	let cached = perRoot.get(start);
+	return bucket;
+}
+/** What the chain installs, see {@link flattenChain} */
+function flattenChainInfo(root, start, resolveAdded) {
+	if (!start) return;
+	const bucket = flattenMemoOf(root);
+	flattenChainMemoReadonly(root, start, resolveAdded);
+	return bucket.info.get(start);
+}
+function flattenChainMemoReadonly(root, start, resolveAdded, skip) {
+	if (!start) return;
+	const bucket = flattenMemoOf(root);
+	let memo = bucket.per;
+	if (skip) {
+		const skipped = bucket.skipped ??= /* @__PURE__ */ new WeakMap();
+		memo = skipped.get(start);
+		if (!memo) skipped.set(start, memo = /* @__PURE__ */ new WeakMap());
+	}
+	let cached = memo.get(skip ?? start);
 	if (cached === void 0) {
-		cached = flattenChain(start, void 0, void 0, resolveAdded) ?? emptyFlatten;
-		perRoot.set(start, cached);
+		const info = skip ? void 0 : {};
+		cached = flattenChain(start, resolveAdded, skip, info) ?? emptyFlatten;
+		memo.set(skip ?? start, cached);
+		if (info?.named) bucket.info.set(start, info);
 	}
-	if (cached === emptyFlatten) return;
-	return cached;
+	if (cached !== emptyFlatten) return cached;
 }
-function flattenChainMemo(root, start, resolveAdded) {
-	const cached = flattenChainMemoReadonly(root, start, resolveAdded);
+function flattenChainMemo(root, start, resolveAdded, skip) {
+	const cached = flattenChainMemoReadonly(root, start, resolveAdded, skip);
 	if (cached) return cloneHook(cached);
 }
 const notLatin = /[^\x00-\xFF]/;
@@ -302,6 +398,7 @@ function formToFormData(value) {
 * ```
 */
 const form = (value) => Object.setPrototypeOf({ ...value }, ELYSIA_FORM_PROTOTYPE);
+const macroType = () => void 0;
 const assignOwn = (target, source) => source != null && Object.hasOwn(source, "__proto__") ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : Object.assign(target, source);
 const getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, -1) : path + "/";
 const byteStreams = /* @__PURE__ */ new WeakSet();
@@ -426,26 +523,6 @@ function mergeArray(a, b, reverse = false) {
 	}
 	return [a, b];
 }
-/**
-* Like {@link mergeArray} but drops entries from `a` that already appear in
-* `b` by reference. Always allocates fresh arrays - never mutates inputs.
-*
-* Used at the compile-time merge of a route's snapshotted `appHook` with the
-* root's current `rootHook`: the same fn can sit on both sides because
-* `.use()` propagates global/plugin-scoped hooks into the parent, while the
-* route's `appHook` was captured on the child and still holds the original.
-* The fn must run once, in `b`'s position.
-*/
-function dedupedMergeArray(a, b, reverse = false) {
-	if (!a) return Array.isArray(b) ? b.slice() : b;
-	if (!b) return Array.isArray(a) ? a.slice() : a;
-	const aArr = Array.isArray(a) ? a : [a];
-	const bArr = Array.isArray(b) ? b : [b];
-	const seen = new Set(bArr);
-	const filtered = [];
-	for (let i = 0; i < aArr.length; i++) if (!seen.has(aArr[i])) filtered.push(aArr[i]);
-	return reverse ? bArr.concat(filtered) : filtered.concat(bArr);
-}
 const hookSchemaKeys = [
 	"body",
 	"headers",
@@ -466,7 +543,7 @@ const hookEventKeys = [
 	"error",
 	"trace"
 ];
-const eventProperties = new Set([
+const lifecycleEvents = [
 	"start",
 	"stop",
 	"trace",
@@ -478,7 +555,8 @@ const eventProperties = new Set([
 	"mapResponse",
 	"afterResponse",
 	"error"
-]);
+];
+const eventProperties = new Set(lifecycleEvents);
 function hookToGuard(a) {
 	if (a.schema !== "merge") {
 		if (a.schema !== void 0 && a.schema !== "override") throw new Error(`[Elysia] Invalid guard schema ${JSON.stringify(a.schema)}, expected 'merge' or 'override' (1.x 'standalone' is 'merge')`);
@@ -515,25 +593,24 @@ function coalesceSchemas(existing, incoming) {
 		if (!merged) existing.push(entry);
 	}
 }
-function mergeHook(a, b, reverse = false, dedup = false) {
+function mergeHook(a, b) {
 	if (!b) return a;
 	if (!a) return b;
-	const merge = dedup ? dedupedMergeArray : mergeArray;
 	for (const key of hookSchemaKeys) if (!a[key] && b[key]) a[key] = b[key];
 	else if (key === "response" && a.response && b.response) a.response = mergeResponse(b.response, a.response);
-	for (const key of hookEventKeys) if (a[key] || b[key]) a[key] = merge(a[key], b[key], reverse);
-	if (a.schemas || b.schemas) a.schemas = mergeArray(a.schemas, b.schemas, reverse);
+	for (const key of hookEventKeys) if (a[key] || b[key]) a[key] = mergeArray(a[key], b[key], true);
+	if (a.schemas || b.schemas) a.schemas = mergeArray(a.schemas, b.schemas, true);
 	const aDerive = a["~deriveEntries"];
 	const bDerive = b["~deriveEntries"];
-	if (aDerive || bDerive) a["~deriveEntries"] = mergeArray(aDerive, bDerive, reverse);
+	if (aDerive || bDerive) a["~deriveEntries"] = mergeArray(aDerive, bDerive, true);
 	return a;
 }
 const createErrorEventHandler = (fn, error) => {
 	const handler = (context) => {
 		if (context.error instanceof error) return fn(context);
 	};
-	const p = error?.prototype;
-	if (typeof p === "object" && p !== null && p !== Error.prototype && !(p instanceof Error)) handler["~errorClass"] = error;
+	const prototype = error?.prototype;
+	if (typeof prototype === "object" && prototype !== null && prototype !== Error.prototype && !(prototype instanceof Error)) handler["~errorClass"] = error;
 	return handler;
 };
 const isObject = (item) => item && typeof item === "object" && !Array.isArray(item);
@@ -623,12 +700,6 @@ function joinPath(base, path) {
 	if (!baseEndsWithSlash && !pathStartsWithSlash) return base + "/" + path;
 	return base + path;
 }
-function pushField(target, key, item) {
-	const v = target[key];
-	if (v) if (Array.isArray(v)) target[key].push(item);
-	else target[key] = [v, item];
-	else target[key] = item;
-}
 const requestId = isBun ? Bun.randomUUIDv7 : crypto.randomUUID.bind(crypto);
 /**
 * Offset of the first byte after `://`, so the authority is never scanned as
@@ -646,22 +717,34 @@ function isPlainObject(v) {
 	const proto = Object.getPrototypeOf(v);
 	return proto === Object.prototype || proto === null;
 }
-function clonePlainDecorators(source, seen) {
-	if (seen !== void 0) {
-		const existing = seen.get(source);
-		if (existing) return existing;
-	}
+function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
+	const existing = seen.get(source);
+	if (existing) return existing;
 	const out = nullObject();
-	if (seen !== void 0) seen.set(source, out);
-	for (const key in source) {
-		const value = source[key];
-		if (isPlainObject(value)) {
-			if (seen === void 0) (seen = /* @__PURE__ */ new WeakMap()).set(source, out);
-			out[key] = clonePlainDecorators(value, seen);
-		} else out[key] = value;
+	seen.set(source, out);
+	for (const key in source) copyKey(source, out, key, seen);
+	const own = Reflect.ownKeys(source);
+	if (own.length !== Object.keys(source).length) for (const key of own) {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (!descriptor || descriptor.enumerable && typeof key === "string") continue;
+		try {
+			copyKey(source, out, key, seen, descriptor);
+		} catch {}
 	}
+	if (!Object.isExtensible(source)) Object.preventExtensions(out);
 	return out;
 }
+const copyKey = (source, out, key, seen, descriptor = Object.getOwnPropertyDescriptor(source, key)) => {
+	let value = source[key];
+	if (isPlainObject(value)) value = clonePlainDecorators(value, seen);
+	if (!descriptor || descriptor.writable !== false && descriptor.enumerable && descriptor.configurable) out[key] = value;
+	else Object.defineProperty(out, key, {
+		value,
+		writable: descriptor.writable ?? true,
+		enumerable: descriptor.enumerable,
+		configurable: descriptor.configurable
+	});
+};
 function prefix(prefix, models) {
 	const prefixed = nullObject();
 	for (const key in models) prefixed[`${prefix}.${key}`] = models[key];
@@ -672,18 +755,14 @@ prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
 	for (const key in models) prefixed[`${prefix}.${key.charAt(0).toUpperCase() + key.slice(1)}`] = models[key];
 	return prefixed;
 };
-const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
-let macroSeedRefCounter = 0;
-function macroSeedRefId(ref) {
-	let id = macroSeedRefIds.get(ref);
-	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
-	return id;
-}
 function serializeMacroSeed(_key, value) {
 	switch (typeof value) {
-		case "function": return "\0fn:" + macroSeedRefId(value);
+		case "function": return "\0ref:" + realmId("~elysiaSeedIds", value);
 		case "bigint": return "\0bigint:" + value.toString();
-		case "symbol": return "\0sym:" + String(value);
+		case "symbol": {
+			const key = Symbol.keyFor(value);
+			return key === void 0 ? "\0ref:" + realmId("~elysiaSeedIds", value) : "\0symfor:" + key;
+		}
 		case "undefined": return "\0undefined";
 		default: return value;
 	}
@@ -704,7 +783,21 @@ const isDisposable = (value) => {
 };
 const singletons = /* @__PURE__ */ new WeakSet();
 const isSingleton = (value) => singletons.has(value);
-const markSingletons = (value, depth = 4, seen = /* @__PURE__ */ new Set()) => {
+function pushHeld(object, into, seen) {
+	if (ArrayBuffer.isView(object)) return;
+	let all = false;
+	try {
+		all = typeof object !== "function" && object !== globalThis && !(object instanceof Error);
+	} catch {}
+	try {
+		const keys = all ? Reflect.ownKeys(object) : [...Object.keys(object), ...Object.getOwnPropertySymbols(object)];
+		for (const key of keys) {
+			const descriptor = Object.getOwnPropertyDescriptor(object, key);
+			if (descriptor && "value" in descriptor) enqueue(descriptor.value, into, seen);
+		}
+	} catch {}
+}
+function enqueue(value, into, seen) {
 	if (value == null) return;
 	const kind = typeof value;
 	if (kind !== "object" && kind !== "function") return;
@@ -712,14 +805,30 @@ const markSingletons = (value, depth = 4, seen = /* @__PURE__ */ new Set()) => {
 	if (seen.has(object)) return;
 	seen.add(object);
 	singletons.add(object);
-	if (depth <= 0) return;
-	for (const key of Object.keys(object)) {
-		const descriptor = Object.getOwnPropertyDescriptor(object, key);
-		if (descriptor && "value" in descriptor) markSingletons(descriptor.value, depth - 1, seen);
+	into.push(object);
+}
+function markLevels(level, depth, seen) {
+	while (level.length && depth > 0) {
+		const next = [];
+		for (const object of level) pushHeld(object, next, seen);
+		level = next;
+		depth--;
 	}
+}
+const markSingletons = (value, depth = 4) => {
+	const seen = /* @__PURE__ */ new Set();
+	const level = [];
+	enqueue(value, level, seen);
+	markLevels(level, depth, seen);
+};
+const markPropertySingletons = (object) => {
+	const seen = /* @__PURE__ */ new Set();
+	const level = [];
+	pushHeld(object, level, seen);
+	markLevels(level, 4, seen);
 };
 const isSocketQuiet = (socket) => socket.readyState === 3 && !socket.data.inflight && !socket.data.opening && !socket.data.settling;
 const isHTMLBundle = (value) => Object.prototype.toString.call(value) === "[object HTMLBundle]" || typeof value?.index === "string" && Array.isArray(value.files);
 
 //#endregion
-export { ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, refTargets, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };
+export { ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, deriveQueues, eventProperties, evictOldestHalf, flattenChain, flattenChainInfo, flattenChainMemo, flattenChainMemoReadonly, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isMapDeriveEntry, isNotEmpty, isPlainDeriveEntry, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, macroType, mapDeriveEntry, markPropertySingletons, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, occurrenceDeriveEntries, pluginHash, pluginId, prefix, redirect, refTargets, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };

package/dist/validator/index.d.ts

@@ -1,8 +1,8 @@
 import { AnySchema, StandardSchemaV1Like } from "../type/types.js";
-import { ElysiaConfig, MaybePromise } from "../types.js";
-import { TypeBoxValidator } from "../type/bridge.js";
 import { CoerceOption } from "../type/coerce.js";
 import { ProgramId, ValidatorSlot } from "../compile/aot.js";
+import { TypeBoxValidator } from "../type/bridge.js";
+import { ElysiaConfig, MaybePromise } from "../types.js";
 import { TSchema } from "typebox/type";
 import { TLocalizedValidationError } from "typebox/error";
 
@@ -38,7 +38,7 @@ declare abstract class Validator {
   static create<const Schema extends TSchema>(schema: Schema, options?: ValidatorOptions): TypeBoxValidator<Schema>;
   static create<const Schema extends StandardSchemaV1Like>(schema: Schema, options?: ValidatorOptions): StandardValidator;
   static create(schema: undefined | null, options?: ValidatorOptions): Validator | undefined;
-  static response(schema: TSchema | StandardSchemaV1Like | Record<number, TSchema | StandardSchemaV1Like> | undefined | null, options?: ResponseValidatorOptions): Record<number, Validator> | undefined;
+  static response(schema: TSchema | StandardSchemaV1Like | Record<number, TSchema | StandardSchemaV1Like> | undefined | null, options?: ResponseValidatorOptions): Map<number, Validator> | undefined;
   static clear(): void;
 }
 declare class StandardValidator extends Validator {

package/dist/validator/index.js

@@ -76,13 +76,13 @@ var Validator = class Validator {
 		}
 		schema = Validator.reference(schema, options?.models);
 		const responseSlot = (status) => options?.aot ? `response:${status}` : void 0;
-		if (isSingleSchema(schema)) return { 200: Validator.create(schema, {
+		if (isSingleSchema(schema)) return new Map([[200, Validator.create(schema, {
 			...options,
 			slot: responseSlot(200),
 			schemas: options?.schemas?.map((s) => toStatusBased(s)[200])?.filter(Boolean)
-		}) };
+		})]]);
 		const entries = Object.entries(schema);
-		return Object.fromEntries(entries.map(([k, v]) => [k, v instanceof Validator ? v : Validator.create(v, {
+		return new Map(entries.map(([k, v]) => [+k, v instanceof Validator ? v : Validator.create(v, {
 			...options,
 			slot: responseSlot(k),
 			schemas: options?.schemas?.map((s) => toStatusBased(s)[k])?.filter(Boolean)
@@ -154,7 +154,7 @@ var MultiValidator = class MultiValidator extends Validator {
 			const compiled = require_type_bridge.Compile(coercedSchema);
 			codecs.push(require_type_bridge.HasCodec(coercedSchema));
 			hasDefaults.push(hd);
-			if (require_type_bridge.TypeBoxValidator.member(coercedSchema, compiled)) {
+			if (require_type_bridge.TypeBoxValidator.isAsyncMember(coercedSchema, compiled)) {
 				this.isAsync = true;
 				asyncMembers.push(Validator.create(rawSchema, {
 					coerces: options?.coerces,

package/dist/validator/index.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { assignOwn } from "../utils.mjs";
 import { Clone, Compile, HasCodec, Intersect, TypeBoxValidator, TypeBoxValidatorCache, applyCoercions } from "../type/bridge.mjs";
 import { ValidationError } from "../error.mjs";
@@ -75,13 +76,13 @@ var Validator = class Validator {
 		}
 		schema = Validator.reference(schema, options?.models);
 		const responseSlot = (status) => options?.aot ? `response:${status}` : void 0;
-		if (isSingleSchema(schema)) return { 200: Validator.create(schema, {
+		if (isSingleSchema(schema)) return new Map([[200, Validator.create(schema, {
 			...options,
 			slot: responseSlot(200),
 			schemas: options?.schemas?.map((s) => toStatusBased(s)[200])?.filter(Boolean)
-		}) };
+		})]]);
 		const entries = Object.entries(schema);
-		return Object.fromEntries(entries.map(([k, v]) => [k, v instanceof Validator ? v : Validator.create(v, {
+		return new Map(entries.map(([k, v]) => [+k, v instanceof Validator ? v : Validator.create(v, {
 			...options,
 			slot: responseSlot(k),
 			schemas: options?.schemas?.map((s) => toStatusBased(s)[k])?.filter(Boolean)
@@ -153,7 +154,7 @@ var MultiValidator = class MultiValidator extends Validator {
 			const compiled = Compile(coercedSchema);
 			codecs.push(HasCodec(coercedSchema));
 			hasDefaults.push(hd);
-			if (TypeBoxValidator.member(coercedSchema, compiled)) {
+			if (TypeBoxValidator.isAsyncMember(coercedSchema, compiled)) {
 				this.isAsync = true;
 				asyncMembers.push(Validator.create(rawSchema, {
 					coerces: options?.coerces,

package/dist/validator/route.d.ts

@@ -1,5 +1,5 @@
 import { AnySchema } from "../type/types.js";
-import { ToSubTypeValidator, ValidatorOptions } from "./index.js";
+import { ToSubTypeValidator, Validator, ValidatorOptions } from "./index.js";
 //#region src/validator/route.d.ts
 interface RouteSchema {
   body?: AnySchema;
@@ -25,7 +25,7 @@ declare class RouteValidator<const in out T extends RouteSchema> {
   query: ToSubTypeValidator<T['query']> | undefined;
   params: ToSubTypeValidator<T['params']> | undefined;
   cookie: ToSubTypeValidator<T['cookie']> | undefined;
-  response: { [Status in keyof T['response']]: ToSubTypeValidator<T['response'][Status]> } | undefined;
+  response: Map<number, Validator> | undefined;
   constructor(route: T, options?: RouteValidatorOptions);
 }
 //#endregion

package/dist/validator/route.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, hasTypes, mayHaveFileType } from "../type/bridge.mjs";
 import { ELYSIA_TYPES } from "../type/constants.mjs";
 import { Validator } from "./index.mjs";

package/dist/ws/context.js

@@ -84,7 +84,7 @@ var ElysiaWS = class {
 		const validators = connectionData?.validator;
 		const defaultValidator = connectionData?.defaultValidator;
 		const status = data instanceof require_error.ElysiaStatus ? data : void 0;
-		const v = validators && (status ? validators[status.status] : defaultValidator);
+		const v = validators && (status ? validators.get(+status.status) : defaultValidator);
 		let value = status ? status.response : data;
 		if (v) {
 			const encode = v.EncodeFrom;

package/dist/ws/context.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { requestId } from "../utils.mjs";
 import { ElysiaStatus, ValidationError } from "../error.mjs";
 
@@ -83,7 +84,7 @@ var ElysiaWS = class {
 		const validators = connectionData?.validator;
 		const defaultValidator = connectionData?.defaultValidator;
 		const status = data instanceof ElysiaStatus ? data : void 0;
-		const v = validators && (status ? validators[status.status] : defaultValidator);
+		const v = validators && (status ? validators.get(+status.status) : defaultValidator);
 		let value = status ? status.response : data;
 		if (v) {
 			const encode = v.EncodeFrom;

package/dist/ws/index.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { ElysiaWS, isGeneratorObject } from "./context.mjs";
 import { createMessageParser, defaultWSParse } from "./parser.mjs";
 import { buildGlobalWSHandler, buildWSRoute } from "./route.mjs";

package/dist/ws/parser.mjs

@@ -1,3 +1,4 @@
+// @bun
 //#region src/ws/parser.ts
 function defaultWSParse(message) {
 	if (typeof message !== "string") return message;