elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/type/bridge.mjs

@@ -31,10 +31,11 @@ let hasTypes = stub("hasTypes");
 let mayHaveFileType = stub("mayHaveFileType");
 let HasCodec = stub("HasCodec");
 let Intersect = stub("Intersect");
-let Default = stub("Default");
 let Ref = stub("Ref");
 let Clone = stub("Clone");
 let Check = stub("Check");
+let warmTypebox = stub("warmTypebox");
+let preloadTypebox = () => void 0;
 const isBridgeLive = () => live !== void 0;
 function useTypebox(mod) {
 	live = mod;
@@ -53,11 +54,12 @@ function useTypebox(mod) {
 	mayHaveFileType = mod.mayHaveFileType;
 	HasCodec = mod.HasCodec;
 	Intersect = mod.Intersect;
-	Default = mod.Default;
 	Ref = mod.Ref;
 	Clone = mod.Clone;
 	Check = mod.Check;
+	warmTypebox = mod.warmTypebox;
+	preloadTypebox = mod.preloadTypebox;
 }
 
 //#endregion
-export { Check, Clone, Compile, Create, Decode, Default, HasCodec, Intersect, Ref, TypeBoxValidator, TypeBoxValidatorCache, applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, hasTypes, isBridgeLive, mayHaveFileType, useTypebox };
+export { Check, Clone, Compile, Create, Decode, HasCodec, Intersect, Ref, TypeBoxValidator, TypeBoxValidatorCache, applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, hasTypes, isBridgeLive, mayHaveFileType, preloadTypebox, useTypebox, warmTypebox };

package/dist/type/coerce-plan.d.ts

@@ -1,12 +1,12 @@
 import { BooleanString } from "./elysia/boolean-string.js";
-import { IntegerString } from "./elysia/integer-string.js";
 import { Numeric } from "./elysia/numeric.js";
-import { clearCoerceLeafCache, coerceLeafCacheSize } from "./shared.js";
+import { clearCoerceLeafCache } from "./shared.js";
+import * as _$typebox from "typebox";
 
 //#region src/type/coerce-plan.d.ts
 declare const COERCE_LEAF_CTOR: {
   readonly 1: typeof Numeric;
-  readonly 2: typeof IntegerString;
+  readonly 2: (property?: _$typebox.TNumberOptions) => Readonly<_$typebox.TUnion<[_$typebox.TInteger, _$typebox.TCodec<_$typebox.TRefine<_$typebox.TString>, number>]>>;
   readonly 3: typeof BooleanString;
 };
 interface CoerceLeaf {
@@ -33,6 +33,6 @@ declare const isCoerceUnion: (x: CoerceNode) => x is CoerceUnion;
 type RebuildObjStr = (original: any, site: CoerceObjStr) => any;
 /** @internal */
 declare const COERCE_LEAF_CACHE_LIMIT = 1024;
-declare function buildCoercedFromPlan(original: any, plan: CoercePlan, seen?: Set<string>, objStr?: RebuildObjStr): any;
+declare function buildCoercedFromPlan(original: any, plan: CoerceNode, seen?: Set<string>, objStr?: RebuildObjStr): any;
 //#endregion
-export { COERCE_LEAF_CACHE_LIMIT, COERCE_LEAF_CTOR, CoerceLeaf, CoerceNode, CoerceObjStr, CoercePlan, CoerceUnion, RebuildObjStr, buildCoercedFromPlan, clearCoerceLeafCache, coerceLeafCacheSize, isCoerceLeaf, isCoerceObjStr, isCoerceUnion };
+export { COERCE_LEAF_CACHE_LIMIT, COERCE_LEAF_CTOR, CoerceLeaf, CoerceNode, CoerceObjStr, CoercePlan, CoerceUnion, RebuildObjStr, buildCoercedFromPlan, clearCoerceLeafCache, isCoerceLeaf, isCoerceObjStr, isCoerceUnion };

package/dist/type/coerce-plan.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_utils = require('../utils.js');
 const require_type_constants = require('./constants.js');
 const require_type_shared = require('./shared.js');
+const require_type_typebox_type = require('./typebox-type.js');
 const require_type_elysia_array = require('./elysia/array.js');
 const require_type_elysia_string = require('./elysia/string.js');
 const require_type_elysia_union = require('./elysia/union.js');
@@ -11,7 +11,6 @@ const require_type_elysia_object = require('./elysia/object.js');
 const require_type_elysia_numeric = require('./elysia/numeric.js');
 const require_type_elysia_boolean_string = require('./elysia/boolean-string.js');
 const require_type_elysia_integer_string = require('./elysia/integer-string.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/coerce-plan.ts
 const COERCE_LEAF_CTOR = {
@@ -25,28 +24,53 @@ const isCoerceUnion = (x) => Array.isArray(x.u);
 const icPlaceholder = () => {
 	throw new Error("[elysia] ObjectString/ArrayString shape placeholder was not reconstructed. missing inner-codec (ic) entry");
 };
-function ObjectStringShape(property, _options) {
-	const [{ properties, ...constraints }, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
-	const object = require_type_elysia_object.ObjectType(property, constraints);
-	const objectString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an object"), icPlaceholder);
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ObjectString, require_type_elysia_union.Union([object, objectString], meta));
-}
-function ArrayStringShape(property, _options) {
-	const [constraints, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
-	const array = require_type_elysia_array.ArrayType(property, constraints);
-	const arrayString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an array"), icPlaceholder);
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayString, require_type_elysia_union.Union([array, arrayString], meta));
-}
 const rebuildObjStrShape = (original, site) => {
 	const { type, ...rest } = original;
-	const node = site.os === require_type_constants.ELYSIA_TYPES.ObjectString ? ObjectStringShape(rest.properties ?? require_utils.nullObject(), rest) : ArrayStringShape(rest.items ?? require_utils.nullObject(), rest);
+	const isObject = site.os === require_type_constants.ELYSIA_TYPES.ObjectString;
+	let inner, meta;
+	if (isObject) {
+		const [{ properties, ...constraints }, m] = require_type_elysia_utils.getMeta(rest);
+		inner = require_type_elysia_object.ObjectType(rest.properties ?? require_utils.nullObject(), constraints);
+		meta = m;
+	} else {
+		const [constraints, m] = require_type_elysia_utils.getMeta(rest);
+		inner = require_type_elysia_array.ArrayType(rest.items ?? require_utils.nullObject(), constraints);
+		meta = m;
+	}
+	const node = require_type_elysia_utils.elyType(isObject ? require_type_constants.ELYSIA_TYPES.ObjectString : require_type_constants.ELYSIA_TYPES.ArrayString, require_type_elysia_union.Union([inner, require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), icPlaceholder, () => isObject ? "must be an object" : "must be an array"), icPlaceholder)], meta));
 	if ("o" in site) return Object.defineProperty(node, "~optional", {
 		value: site.o,
 		enumerable: false
 	});
 	return node;
 };
-const buildCoerceNode = (original, node, seen, objStr) => isCoerceLeaf(node) ? coerceLeaf(node, seen) : isCoerceObjStr(node) ? objStr(original, node) : isCoerceUnion(node) ? rebuildUnion(original, node, seen, objStr) : buildCoercedFromPlan(original, node, seen, objStr);
+const buildCoerceNode = (original, node, seen, objStr) => {
+	if (isCoerceLeaf(node)) {
+		const key = node.e + (node.c ? JSON.stringify(node.c) : "");
+		let leaf;
+		if (seen.has(key)) leaf = COERCE_LEAF_CTOR[node.e](node.c);
+		else {
+			seen.add(key);
+			leaf = require_type_shared.coerceLeafCache.get(key);
+			if (leaf === void 0) {
+				leaf = COERCE_LEAF_CTOR[node.e](node.c);
+				if (require_type_shared.coerceLeafCache.size >= 1024) require_utils.evictOldestHalf(require_type_shared.coerceLeafCache);
+				require_type_shared.coerceLeafCache.set(key, leaf);
+			} else if (require_type_shared.coerceLeafCache.size >= 1024) {
+				require_type_shared.coerceLeafCache.delete(key);
+				require_type_shared.coerceLeafCache.set(key, leaf);
+			}
+		}
+		if ("o" in node) return Object.defineProperty(Object.create(leaf), "~optional", {
+			value: node.o,
+			enumerable: false
+		});
+		return leaf;
+	}
+	if (isCoerceObjStr(node)) return objStr(original, node);
+	if (isCoerceUnion(node)) return rebuildUnion(original, node, seen, objStr);
+	return buildCoercedFromPlan(original, node, seen, objStr);
+};
 function cloneSchemaNode(original) {
 	const out = Object.create(Object.getPrototypeOf(original));
 	for (const k in original) out[k] = original[k];
@@ -63,29 +87,8 @@ function rebuildUnion(original, site, seen, objStr) {
 }
 /** @internal */
 const COERCE_LEAF_CACHE_LIMIT = 1024;
-function coerceLeaf(leaf, seen) {
-	const key = leaf.e + (leaf.c ? JSON.stringify(leaf.c) : "");
-	let node;
-	if (seen.has(key)) node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
-	else {
-		seen.add(key);
-		node = require_type_shared.coerceLeafCache.get(key);
-		if (node === void 0) {
-			node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
-			if (require_type_shared.coerceLeafCache.size >= 1024) require_utils.evictOldestHalf(require_type_shared.coerceLeafCache);
-			require_type_shared.coerceLeafCache.set(key, node);
-		} else if (require_type_shared.coerceLeafCache.size >= 1024) {
-			require_type_shared.coerceLeafCache.delete(key);
-			require_type_shared.coerceLeafCache.set(key, node);
-		}
-	}
-	if ("o" in leaf) return Object.defineProperty(Object.create(node), "~optional", {
-		value: leaf.o,
-		enumerable: false
-	});
-	return node;
-}
 function buildCoercedFromPlan(original, plan, seen = /* @__PURE__ */ new Set(), objStr = rebuildObjStrShape) {
+	if (isCoerceLeaf(plan) || isCoerceObjStr(plan) || isCoerceUnion(plan)) return buildCoerceNode(original, plan, seen, objStr);
 	const out = cloneSchemaNode(original);
 	if (plan.p) {
 		const props = { ...original.properties };
@@ -101,7 +104,6 @@ exports.COERCE_LEAF_CACHE_LIMIT = COERCE_LEAF_CACHE_LIMIT;
 exports.COERCE_LEAF_CTOR = COERCE_LEAF_CTOR;
 exports.buildCoercedFromPlan = buildCoercedFromPlan;
 exports.clearCoerceLeafCache = require_type_shared.clearCoerceLeafCache;
-exports.coerceLeafCacheSize = require_type_shared.coerceLeafCacheSize;
 exports.isCoerceLeaf = isCoerceLeaf;
 exports.isCoerceObjStr = isCoerceObjStr;
 exports.isCoerceUnion = isCoerceUnion;

package/dist/type/coerce-plan.mjs

@@ -1,6 +1,7 @@
 import { evictOldestHalf, nullObject } from "../utils.mjs";
 import { ELYSIA_TYPES } from "./constants.mjs";
-import { clearCoerceLeafCache, coerceLeafCache, coerceLeafCacheSize } from "./shared.mjs";
+import { clearCoerceLeafCache, coerceLeafCache } from "./shared.mjs";
+import { Decode, Refine } from "./typebox-type.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -9,7 +10,6 @@ import { ObjectType } from "./elysia/object.mjs";
 import { Numeric } from "./elysia/numeric.mjs";
 import { BooleanString } from "./elysia/boolean-string.mjs";
 import { IntegerString } from "./elysia/integer-string.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/coerce-plan.ts
 const COERCE_LEAF_CTOR = {
@@ -23,28 +23,53 @@ const isCoerceUnion = (x) => Array.isArray(x.u);
 const icPlaceholder = () => {
 	throw new Error("[elysia] ObjectString/ArrayString shape placeholder was not reconstructed. missing inner-codec (ic) entry");
 };
-function ObjectStringShape(property, _options) {
-	const [{ properties, ...constraints }, meta] = getMeta(_options ?? nullObject());
-	const object = ObjectType(property, constraints);
-	const objectString = Decode(Refine(StringType(), icPlaceholder, () => "must be an object"), icPlaceholder);
-	return elyType(ELYSIA_TYPES.ObjectString, Union([object, objectString], meta));
-}
-function ArrayStringShape(property, _options) {
-	const [constraints, meta] = getMeta(_options ?? nullObject());
-	const array = ArrayType(property, constraints);
-	const arrayString = Decode(Refine(StringType(), icPlaceholder, () => "must be an array"), icPlaceholder);
-	return elyType(ELYSIA_TYPES.ArrayString, Union([array, arrayString], meta));
-}
 const rebuildObjStrShape = (original, site) => {
 	const { type, ...rest } = original;
-	const node = site.os === ELYSIA_TYPES.ObjectString ? ObjectStringShape(rest.properties ?? nullObject(), rest) : ArrayStringShape(rest.items ?? nullObject(), rest);
+	const isObject = site.os === ELYSIA_TYPES.ObjectString;
+	let inner, meta;
+	if (isObject) {
+		const [{ properties, ...constraints }, m] = getMeta(rest);
+		inner = ObjectType(rest.properties ?? nullObject(), constraints);
+		meta = m;
+	} else {
+		const [constraints, m] = getMeta(rest);
+		inner = ArrayType(rest.items ?? nullObject(), constraints);
+		meta = m;
+	}
+	const node = elyType(isObject ? ELYSIA_TYPES.ObjectString : ELYSIA_TYPES.ArrayString, Union([inner, Decode(Refine(StringType(), icPlaceholder, () => isObject ? "must be an object" : "must be an array"), icPlaceholder)], meta));
 	if ("o" in site) return Object.defineProperty(node, "~optional", {
 		value: site.o,
 		enumerable: false
 	});
 	return node;
 };
-const buildCoerceNode = (original, node, seen, objStr) => isCoerceLeaf(node) ? coerceLeaf(node, seen) : isCoerceObjStr(node) ? objStr(original, node) : isCoerceUnion(node) ? rebuildUnion(original, node, seen, objStr) : buildCoercedFromPlan(original, node, seen, objStr);
+const buildCoerceNode = (original, node, seen, objStr) => {
+	if (isCoerceLeaf(node)) {
+		const key = node.e + (node.c ? JSON.stringify(node.c) : "");
+		let leaf;
+		if (seen.has(key)) leaf = COERCE_LEAF_CTOR[node.e](node.c);
+		else {
+			seen.add(key);
+			leaf = coerceLeafCache.get(key);
+			if (leaf === void 0) {
+				leaf = COERCE_LEAF_CTOR[node.e](node.c);
+				if (coerceLeafCache.size >= 1024) evictOldestHalf(coerceLeafCache);
+				coerceLeafCache.set(key, leaf);
+			} else if (coerceLeafCache.size >= 1024) {
+				coerceLeafCache.delete(key);
+				coerceLeafCache.set(key, leaf);
+			}
+		}
+		if ("o" in node) return Object.defineProperty(Object.create(leaf), "~optional", {
+			value: node.o,
+			enumerable: false
+		});
+		return leaf;
+	}
+	if (isCoerceObjStr(node)) return objStr(original, node);
+	if (isCoerceUnion(node)) return rebuildUnion(original, node, seen, objStr);
+	return buildCoercedFromPlan(original, node, seen, objStr);
+};
 function cloneSchemaNode(original) {
 	const out = Object.create(Object.getPrototypeOf(original));
 	for (const k in original) out[k] = original[k];
@@ -61,29 +86,8 @@ function rebuildUnion(original, site, seen, objStr) {
 }
 /** @internal */
 const COERCE_LEAF_CACHE_LIMIT = 1024;
-function coerceLeaf(leaf, seen) {
-	const key = leaf.e + (leaf.c ? JSON.stringify(leaf.c) : "");
-	let node;
-	if (seen.has(key)) node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
-	else {
-		seen.add(key);
-		node = coerceLeafCache.get(key);
-		if (node === void 0) {
-			node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
-			if (coerceLeafCache.size >= 1024) evictOldestHalf(coerceLeafCache);
-			coerceLeafCache.set(key, node);
-		} else if (coerceLeafCache.size >= 1024) {
-			coerceLeafCache.delete(key);
-			coerceLeafCache.set(key, node);
-		}
-	}
-	if ("o" in leaf) return Object.defineProperty(Object.create(node), "~optional", {
-		value: leaf.o,
-		enumerable: false
-	});
-	return node;
-}
 function buildCoercedFromPlan(original, plan, seen = /* @__PURE__ */ new Set(), objStr = rebuildObjStrShape) {
+	if (isCoerceLeaf(plan) || isCoerceObjStr(plan) || isCoerceUnion(plan)) return buildCoerceNode(original, plan, seen, objStr);
 	const out = cloneSchemaNode(original);
 	if (plan.p) {
 		const props = { ...original.properties };
@@ -95,4 +99,4 @@ function buildCoercedFromPlan(original, plan, seen = /* @__PURE__ */ new Set(),
 }
 
 //#endregion
-export { COERCE_LEAF_CACHE_LIMIT, COERCE_LEAF_CTOR, buildCoercedFromPlan, clearCoerceLeafCache, coerceLeafCacheSize, isCoerceLeaf, isCoerceObjStr, isCoerceUnion };
+export { COERCE_LEAF_CACHE_LIMIT, COERCE_LEAF_CTOR, buildCoercedFromPlan, clearCoerceLeafCache, isCoerceLeaf, isCoerceObjStr, isCoerceUnion };

package/dist/type/coerce.d.ts

@@ -13,10 +13,6 @@ interface CoerceOptions {
    * - `undefined`: Replace all schemas regardless of level
    */
   root?: boolean | undefined;
-  /**
-   * Replace only the first specified type found
-   **/
-  onlyFirst?: 'object' | 'array' | (string & {});
   /**
    * Only root object
    */
@@ -34,10 +30,10 @@ declare const coerceQuery: () => CoerceOption[];
 declare const coerceBody: () => CoerceOption[];
 declare const coerceFormData: () => CoerceOption[];
 declare const coerceStringToStructure: () => CoerceOption[];
-declare function applyCoercions(schema: BaseSchema | TSchema, coerces: CoerceOption[] | undefined): BaseSchema | TSchema;
-declare function captureCoercePlan(original: any, coerced: any): CoercePlan | null;
+declare function applyCoercions(schema: BaseSchema | TSchema, coerces: CoerceOption[] | undefined): TSchema | BaseSchema;
+declare function captureCoercePlan(original: any, coerced: any): CoerceNode | null;
 /** Full rebuild: scalar leaves + ObjectString/ArrayString sites (wired path). */
-declare const buildCoercedFromPlan: (original: any, plan: CoercePlan, seen?: Set<string>) => any;
+declare const buildCoercedFromPlan: (original: any, plan: CoerceNode, seen?: Set<string>) => any;
 declare function deferCoercions(): void;
 //#endregion
 export { type CoerceLeaf, type CoerceNode, type CoerceObjStr, CoerceOption, type CoercePlan, applyCoercions, buildCoercedFromPlan, captureCoercePlan, clearCoerceLeafCache, coerce, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, deferCoercions, nonAdditionalProperties };

package/dist/type/coerce.js

@@ -18,9 +18,8 @@ function coerce(schema, fromTo, options) {
 	for (const [from, to] of fromTo) if (!transformMap.has(from)) transformMap.set(from, to);
 	const rootOption = options?.root;
 	const memo = /* @__PURE__ */ new WeakMap();
-	let stopped = false;
 	function walk(node, isRoot, isRootProperty = false) {
-		if (!node || stopped || typeof node !== "object" || node["~elyTyp"] && require_type_constants.primitiveElysiaTypes.has(node["~elyTyp"])) return node;
+		if (!node || typeof node !== "object" || node["~elyTyp"] && require_type_constants.primitiveElysiaTypes.has(node["~elyTyp"])) return node;
 		const memoed = memo.get(node);
 		if (memoed !== void 0) return memoed ?? node;
 		if (options?.rootPropertiesOnly && !isRoot && !isRootProperty) return node;
@@ -34,74 +33,18 @@ function coerce(schema, fromTo, options) {
 				const { type, ...rest } = node;
 				let result = to(rest);
 				if (result !== null) {
-					if (options?.onlyFirst === kind) stopped = true;
-					if ("~optional" in node) if (Object.isFrozen(result)) result = Object.defineProperty(Object.create(result), "~optional", {
-						value: node["~optional"],
-						enumerable: false
-					});
-					else Object.defineProperty(result, "~optional", {
-						value: node["~optional"],
-						enumerable: false
-					});
+					if ("~optional" in node) {
+						if (Object.isFrozen(result)) result = Object.create(result);
+						Object.defineProperty(result, "~optional", {
+							value: node["~optional"],
+							enumerable: false
+						});
+					}
 					memo.set(node, result);
 					return result;
 				}
 			}
 		}
-		if (stopped) return node;
-		if (options?.rootPropertiesOnly && isRootProperty) {
-			let out = node;
-			for (const key of [
-				"anyOf",
-				"oneOf",
-				"allOf"
-			]) {
-				const arr = node[key];
-				if (!Array.isArray(arr)) continue;
-				let newArr;
-				for (let i = 0, len = arr.length; i < len; i++) {
-					const item = arr[i];
-					const r = walk(item, false, true);
-					if (stopped && !newArr) {
-						memo.set(node, node);
-						return node;
-					}
-					if (r !== item) {
-						newArr ??= arr.slice();
-						newArr[i] = r;
-					}
-				}
-				if (newArr) {
-					out = require_type_shared.cloneNode(node, out);
-					out[key] = newArr;
-				}
-			}
-			if (node.items) {
-				const items = node.items;
-				if (Array.isArray(items)) {
-					let newItems;
-					for (let i = 0, len = items.length; i < len; i++) {
-						const r = walk(items[i], false, true);
-						if (r !== items[i]) {
-							newItems ??= items.slice();
-							newItems[i] = r;
-						}
-					}
-					if (newItems) {
-						out = require_type_shared.cloneNode(node, out);
-						out.items = newItems;
-					}
-				} else {
-					const r = walk(items, false, true);
-					if (r !== items) {
-						out = require_type_shared.cloneNode(node, out);
-						out.items = r;
-					}
-				}
-			}
-			memo.set(node, out);
-			return out;
-		}
 		let out = node;
 		for (const key of [
 			"anyOf",
@@ -113,8 +56,7 @@ function coerce(schema, fromTo, options) {
 			let newArr;
 			for (let i = 0, len = arr.length; i < len; i++) {
 				const item = arr[i];
-				const r = walk(item, false);
-				if (stopped && !newArr) return node;
+				const r = walk(item, false, isRootProperty);
 				if (r !== item) {
 					newArr ??= arr.slice();
 					newArr[i] = r;
@@ -125,7 +67,7 @@ function coerce(schema, fromTo, options) {
 				out[key] = newArr;
 			}
 		}
-		if (node.not) {
+		if (node.not && !isRootProperty) {
 			const r = walk(node.not, false);
 			if (r !== node.not) {
 				out = require_type_shared.cloneNode(node, out);
@@ -138,7 +80,7 @@ function coerce(schema, fromTo, options) {
 				let newItems;
 				for (let i = 0, len = items.length; i < len; i++) {
 					const item = items[i];
-					const r = walk(item, false);
+					const r = walk(item, false, isRootProperty);
 					if (r !== item) {
 						newItems ??= items.slice();
 						newItems[i] = r;
@@ -149,13 +91,17 @@ function coerce(schema, fromTo, options) {
 					out.items = newItems;
 				}
 			} else {
-				const r = walk(items, false);
+				const r = walk(items, false, isRootProperty);
 				if (r !== items) {
 					out = require_type_shared.cloneNode(node, out);
 					out.items = r;
 				}
 			}
 		}
+		if (isRootProperty) {
+			memo.set(node, out);
+			return out;
+		}
 		if (node.properties) {
 			let newProps;
 			const props = node.properties;
@@ -231,10 +177,7 @@ const coerceFormData = () => _coerceFormData ??= [
 	[[["Integer", require_type_elysia_integer_string.IntegerString]]],
 	...coerceRoot(),
 	[[["Object", toObjectString]], { rootPropertiesOnly: true }],
-	[[["Array", toArrayString]], {
-		root: false,
-		onlyFirst: "array"
-	}]
+	[[["Array", toArrayString]], { root: false }]
 ];
 let _coerceStringToStructure;
 const coerceStringToStructure = () => _coerceStringToStructure ??= [[[["Object", toObjectString], ["Array", toArrayString]], { rootPropertiesOnly: true }], ...coerceRoot()];
@@ -308,7 +251,7 @@ function captureCoercePlan(original, coerced) {
 		return plan.p || plan.i ? plan : null;
 	};
 	const plan = walk(original, coerced);
-	if (!bakeable || !any || !plan || require_type_coerce_plan.isCoerceLeaf(plan) || require_type_coerce_plan.isCoerceObjStr(plan) || require_type_coerce_plan.isCoerceUnion(plan)) return null;
+	if (!bakeable || !any || !plan) return null;
 	if (!jsonSafe(plan)) return null;
 	return plan;
 }

package/dist/type/coerce.mjs

@@ -6,7 +6,7 @@ import { ObjectString } from "./elysia/object-string.mjs";
 import { Numeric } from "./elysia/numeric.mjs";
 import { BooleanString } from "./elysia/boolean-string.mjs";
 import { IntegerString } from "./elysia/integer-string.mjs";
-import { COERCE_LEAF_CTOR, buildCoercedFromPlan as buildCoercedFromPlan$1, isCoerceLeaf, isCoerceObjStr, isCoerceUnion } from "./coerce-plan.mjs";
+import { COERCE_LEAF_CTOR, buildCoercedFromPlan as buildCoercedFromPlan$1 } from "./coerce-plan.mjs";
 
 //#region src/type/coerce.ts
 /**
@@ -17,9 +17,8 @@ function coerce(schema, fromTo, options) {
 	for (const [from, to] of fromTo) if (!transformMap.has(from)) transformMap.set(from, to);
 	const rootOption = options?.root;
 	const memo = /* @__PURE__ */ new WeakMap();
-	let stopped = false;
 	function walk(node, isRoot, isRootProperty = false) {
-		if (!node || stopped || typeof node !== "object" || node["~elyTyp"] && primitiveElysiaTypes.has(node["~elyTyp"])) return node;
+		if (!node || typeof node !== "object" || node["~elyTyp"] && primitiveElysiaTypes.has(node["~elyTyp"])) return node;
 		const memoed = memo.get(node);
 		if (memoed !== void 0) return memoed ?? node;
 		if (options?.rootPropertiesOnly && !isRoot && !isRootProperty) return node;
@@ -33,74 +32,18 @@ function coerce(schema, fromTo, options) {
 				const { type, ...rest } = node;
 				let result = to(rest);
 				if (result !== null) {
-					if (options?.onlyFirst === kind) stopped = true;
-					if ("~optional" in node) if (Object.isFrozen(result)) result = Object.defineProperty(Object.create(result), "~optional", {
-						value: node["~optional"],
-						enumerable: false
-					});
-					else Object.defineProperty(result, "~optional", {
-						value: node["~optional"],
-						enumerable: false
-					});
+					if ("~optional" in node) {
+						if (Object.isFrozen(result)) result = Object.create(result);
+						Object.defineProperty(result, "~optional", {
+							value: node["~optional"],
+							enumerable: false
+						});
+					}
 					memo.set(node, result);
 					return result;
 				}
 			}
 		}
-		if (stopped) return node;
-		if (options?.rootPropertiesOnly && isRootProperty) {
-			let out = node;
-			for (const key of [
-				"anyOf",
-				"oneOf",
-				"allOf"
-			]) {
-				const arr = node[key];
-				if (!Array.isArray(arr)) continue;
-				let newArr;
-				for (let i = 0, len = arr.length; i < len; i++) {
-					const item = arr[i];
-					const r = walk(item, false, true);
-					if (stopped && !newArr) {
-						memo.set(node, node);
-						return node;
-					}
-					if (r !== item) {
-						newArr ??= arr.slice();
-						newArr[i] = r;
-					}
-				}
-				if (newArr) {
-					out = cloneNode(node, out);
-					out[key] = newArr;
-				}
-			}
-			if (node.items) {
-				const items = node.items;
-				if (Array.isArray(items)) {
-					let newItems;
-					for (let i = 0, len = items.length; i < len; i++) {
-						const r = walk(items[i], false, true);
-						if (r !== items[i]) {
-							newItems ??= items.slice();
-							newItems[i] = r;
-						}
-					}
-					if (newItems) {
-						out = cloneNode(node, out);
-						out.items = newItems;
-					}
-				} else {
-					const r = walk(items, false, true);
-					if (r !== items) {
-						out = cloneNode(node, out);
-						out.items = r;
-					}
-				}
-			}
-			memo.set(node, out);
-			return out;
-		}
 		let out = node;
 		for (const key of [
 			"anyOf",
@@ -112,8 +55,7 @@ function coerce(schema, fromTo, options) {
 			let newArr;
 			for (let i = 0, len = arr.length; i < len; i++) {
 				const item = arr[i];
-				const r = walk(item, false);
-				if (stopped && !newArr) return node;
+				const r = walk(item, false, isRootProperty);
 				if (r !== item) {
 					newArr ??= arr.slice();
 					newArr[i] = r;
@@ -124,7 +66,7 @@ function coerce(schema, fromTo, options) {
 				out[key] = newArr;
 			}
 		}
-		if (node.not) {
+		if (node.not && !isRootProperty) {
 			const r = walk(node.not, false);
 			if (r !== node.not) {
 				out = cloneNode(node, out);
@@ -137,7 +79,7 @@ function coerce(schema, fromTo, options) {
 				let newItems;
 				for (let i = 0, len = items.length; i < len; i++) {
 					const item = items[i];
-					const r = walk(item, false);
+					const r = walk(item, false, isRootProperty);
 					if (r !== item) {
 						newItems ??= items.slice();
 						newItems[i] = r;
@@ -148,13 +90,17 @@ function coerce(schema, fromTo, options) {
 					out.items = newItems;
 				}
 			} else {
-				const r = walk(items, false);
+				const r = walk(items, false, isRootProperty);
 				if (r !== items) {
 					out = cloneNode(node, out);
 					out.items = r;
 				}
 			}
 		}
+		if (isRootProperty) {
+			memo.set(node, out);
+			return out;
+		}
 		if (node.properties) {
 			let newProps;
 			const props = node.properties;
@@ -230,10 +176,7 @@ const coerceFormData = () => _coerceFormData ??= [
 	[[["Integer", IntegerString]]],
 	...coerceRoot(),
 	[[["Object", toObjectString]], { rootPropertiesOnly: true }],
-	[[["Array", toArrayString]], {
-		root: false,
-		onlyFirst: "array"
-	}]
+	[[["Array", toArrayString]], { root: false }]
 ];
 let _coerceStringToStructure;
 const coerceStringToStructure = () => _coerceStringToStructure ??= [[[["Object", toObjectString], ["Array", toArrayString]], { rootPropertiesOnly: true }], ...coerceRoot()];
@@ -307,7 +250,7 @@ function captureCoercePlan(original, coerced) {
 		return plan.p || plan.i ? plan : null;
 	};
 	const plan = walk(original, coerced);
-	if (!bakeable || !any || !plan || isCoerceLeaf(plan) || isCoerceObjStr(plan) || isCoerceUnion(plan)) return null;
+	if (!bakeable || !any || !plan) return null;
 	if (!jsonSafe(plan)) return null;
 	return plan;
 }

package/dist/type/compat.d.ts

@@ -1,8 +1,11 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { TypeboxNamespaces } from "./typebox-value.js";
 import { CreateMirror } from "./validator/exact-mirror.js";
 
 //#region src/type/compat.d.ts
 declare function setupTypebox(options?: {
   exactMirror?: CreateMirror;
+  typebox?: Partial<TypeboxNamespaces & TypeboxTypeNamespaces>;
 }): void;
 //#endregion
 export { setupTypebox };