elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/plugin/vite.mjs

@@ -1,4 +1,4 @@
-import { generateCompiledModule, resolveEntry } from "./core.mjs";
+import { STUB_SOURCES, generateCompiledArtifacts, resolveEntry } from "./core.mjs";
 import { rewriteTypeImport } from "./treeshake.mjs";
 
 //#region src/plugin/vite.ts
@@ -17,17 +17,34 @@ const VIRTUAL = "\0elysia/compiled";
 *   plugins: [aot('src/index.ts')]
 * })
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — can keep the build process alive after
+* the bundle is written. Gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => {
 	const entryPath = resolveEntry(entry);
 	const treeShake = options?.treeShake ?? true;
 	let source = "";
+	let stub = {
+		jit: false,
+		ws: false,
+		reconstruct: false,
+		cookie: false,
+		trace: false,
+		sucrose: false
+	};
 	return {
 		name: "elysia-aot",
 		enforce: "pre",
 		apply: "build",
 		async buildStart() {
-			source = await generateCompiledModule(entry, options);
+			const generated = await generateCompiledArtifacts(entry, options);
+			source = generated.source;
+			stub = generated.stub;
 		},
 		resolveId(id) {
 			if (id === "elysia/compiled") return VIRTUAL;
@@ -36,6 +53,10 @@ const aot = (entry, options) => {
 			if (id === VIRTUAL) return source;
 		},
 		transform(code, id) {
+			for (const key of Object.keys(STUB_SOURCES)) {
+				if (!stub[key]) continue;
+				for (const { filter, source: stubSource } of STUB_SOURCES[key]) if (filter.test(id)) return stubSource;
+			}
 			let out = code;
 			if (treeShake && SOURCE.test(id) && !id.includes("node_modules")) out = rewriteTypeImport(out);
 			if (id === entryPath) out = `import 'elysia/compiled'\n${out}`;

package/dist/sucrose.js

@@ -14,7 +14,7 @@ const require_utils = require('./utils.js');
 function separateFunction(code) {
 	if (code.startsWith("async")) code = code.slice(5);
 	code = code.trimStart();
-	let index = -1;
+	let index;
 	if (code.charCodeAt(0) === 40) {
 		index = code.indexOf("=>", code.indexOf(")"));
 		if (index !== -1) {
@@ -167,10 +167,19 @@ function findParameterReference(parameter, inference) {
 	return Object.keys(parameters).join(", ");
 }
 function findEndIndex(type, content, index) {
-	const regex = new RegExp(`${type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\n\\t,; ]`);
-	if (index !== void 0) regex.lastIndex = index;
-	const match = regex.exec(content);
-	return match ? match.index : -1;
+	let search = index ?? 0;
+	while (true) {
+		const found = content.indexOf(type, search);
+		if (found === -1) return -1;
+		switch (content.charCodeAt(found + type.length)) {
+			case 10:
+			case 9:
+			case 44:
+			case 59:
+			case 32: return found;
+		}
+		search = found + 1;
+	}
 }
 /**
 * Find alias of variable from function body
@@ -246,7 +255,7 @@ function extractMainParameter(parameter) {
 * Analyze if context is mentioned in body
 */
 function inferBodyReference(code, aliases, inference) {
-	const access = (type, alias) => new RegExp(`${alias}\\??\\.(${type})|${alias}(?:\\?\\.)?\\["${type}"\\]|${alias}(?:\\?\\.)?\\['${type}'\\]`).test(code);
+	const access = (type, alias) => code.includes(`${alias}.${type}`) || code.includes(`${alias}?.${type}`) || code.includes(`${alias}["${type}"]`) || code.includes(`${alias}?.["${type}"]`) || code.includes(`${alias}['${type}']`) || code.includes(`${alias}?.['${type}']`);
 	for (const alias of aliases) {
 		if (!alias) continue;
 		if (alias.charCodeAt(0) === 123) {
@@ -357,6 +366,11 @@ function clearSucroseCache(delay) {
 		clearCache();
 	}
 }
+function scheduleSucroseCacheClear() {
+	if (pendingGC || require_universal_constants.isCloudflareWorker) return;
+	pendingGC = setTimeout(clearCache, 60 * 1e3);
+	pendingGC.unref?.();
+}
 function mergeInference(a, b) {
 	return {
 		body: a.body || b.body,
@@ -425,9 +439,9 @@ function sucrose(handler, lifeCycle) {
 		inference ??= defaultSucrose();
 		if (needGc) {
 			needGc = false;
-			clearSucroseCache();
+			scheduleSucroseCacheClear();
 		}
-		let fnInference = defaultSucrose();
+		const fnInference = defaultSucrose();
 		const [parameter, body] = separateFunction(content);
 		const mainParameter = extractMainParameter(findParameterReference(parameter, fnInference));
 		if (mainParameter) {
@@ -448,8 +462,7 @@ function sucrose(handler, lifeCycle) {
 		}
 		if (typeof event === "function") functionCaches.set(event, fnInference);
 		inference = mergeInference(inference, fnInference);
-		fnInference = void 0;
-		if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path) break;
+		if (inference && inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path) break;
 	}
 	events.length = 0;
 	return inference ?? defaultSucrose();

package/dist/sucrose.mjs

@@ -13,7 +13,7 @@ import { fnv1a } from "./utils.mjs";
 function separateFunction(code) {
 	if (code.startsWith("async")) code = code.slice(5);
 	code = code.trimStart();
-	let index = -1;
+	let index;
 	if (code.charCodeAt(0) === 40) {
 		index = code.indexOf("=>", code.indexOf(")"));
 		if (index !== -1) {
@@ -166,10 +166,19 @@ function findParameterReference(parameter, inference) {
 	return Object.keys(parameters).join(", ");
 }
 function findEndIndex(type, content, index) {
-	const regex = new RegExp(`${type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\n\\t,; ]`);
-	if (index !== void 0) regex.lastIndex = index;
-	const match = regex.exec(content);
-	return match ? match.index : -1;
+	let search = index ?? 0;
+	while (true) {
+		const found = content.indexOf(type, search);
+		if (found === -1) return -1;
+		switch (content.charCodeAt(found + type.length)) {
+			case 10:
+			case 9:
+			case 44:
+			case 59:
+			case 32: return found;
+		}
+		search = found + 1;
+	}
 }
 /**
 * Find alias of variable from function body
@@ -245,7 +254,7 @@ function extractMainParameter(parameter) {
 * Analyze if context is mentioned in body
 */
 function inferBodyReference(code, aliases, inference) {
-	const access = (type, alias) => new RegExp(`${alias}\\??\\.(${type})|${alias}(?:\\?\\.)?\\["${type}"\\]|${alias}(?:\\?\\.)?\\['${type}'\\]`).test(code);
+	const access = (type, alias) => code.includes(`${alias}.${type}`) || code.includes(`${alias}?.${type}`) || code.includes(`${alias}["${type}"]`) || code.includes(`${alias}?.["${type}"]`) || code.includes(`${alias}['${type}']`) || code.includes(`${alias}?.['${type}']`);
 	for (const alias of aliases) {
 		if (!alias) continue;
 		if (alias.charCodeAt(0) === 123) {
@@ -356,6 +365,11 @@ function clearSucroseCache(delay) {
 		clearCache();
 	}
 }
+function scheduleSucroseCacheClear() {
+	if (pendingGC || isCloudflareWorker) return;
+	pendingGC = setTimeout(clearCache, 60 * 1e3);
+	pendingGC.unref?.();
+}
 function mergeInference(a, b) {
 	return {
 		body: a.body || b.body,
@@ -424,9 +438,9 @@ function sucrose(handler, lifeCycle) {
 		inference ??= defaultSucrose();
 		if (needGc) {
 			needGc = false;
-			clearSucroseCache();
+			scheduleSucroseCacheClear();
 		}
-		let fnInference = defaultSucrose();
+		const fnInference = defaultSucrose();
 		const [parameter, body] = separateFunction(content);
 		const mainParameter = extractMainParameter(findParameterReference(parameter, fnInference));
 		if (mainParameter) {
@@ -447,8 +461,7 @@ function sucrose(handler, lifeCycle) {
 		}
 		if (typeof event === "function") functionCaches.set(event, fnInference);
 		inference = mergeInference(inference, fnInference);
-		fnInference = void 0;
-		if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path) break;
+		if (inference && inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path) break;
 	}
 	events.length = 0;
 	return inference ?? defaultSucrose();

package/dist/trace.d.ts

@@ -177,4 +177,4 @@ declare class TracerHandle {
 }
 declare const createTracer: (traceListener: TraceHandler) => (context: Context) => TracerHandle;
 //#endregion
-export { TraceEvent, TraceHandler, TraceListener, TraceProcess, TraceStream, createTracer };
+export { TraceEndDetail, TraceEvent, TraceHandler, TraceListener, TraceProcess, TraceStream, createTracer };

package/dist/trace.js

@@ -264,12 +264,10 @@ var TracerLifecycle = class {
 		return this.#handle.listen(8);
 	}
 };
-const createTracer = (traceListener) => {
-	return (context) => {
-		const handle = new TracerHandle();
-		traceListener(new TracerLifecycle(handle, context));
-		return handle;
-	};
+const createTracer = (traceListener) => (context) => {
+	const handle = new TracerHandle();
+	traceListener(new TracerLifecycle(handle, context));
+	return handle;
 };
 
 //#endregion

package/dist/trace.mjs

@@ -262,12 +262,10 @@ var TracerLifecycle = class {
 		return this.#handle.listen(8);
 	}
 };
-const createTracer = (traceListener) => {
-	return (context) => {
-		const handle = new TracerHandle();
-		traceListener(new TracerLifecycle(handle, context));
-		return handle;
-	};
+const createTracer = (traceListener) => (context) => {
+	const handle = new TracerHandle();
+	traceListener(new TracerLifecycle(handle, context));
+	return handle;
 };
 
 //#endregion

package/dist/type/bridge.d.ts

@@ -1,15 +1,16 @@
-import { Intersect as Intersect$2 } from "./elysia/intersect.js";
+import { Intersect as Intersect$1 } from "./elysia/intersect.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
-import { TypeBoxValidator as TypeBoxValidator$1, TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
-import { Compile as Compile$1 } from "typebox/compile";
+import { TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator/validator-cache.js";
+import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
-import { Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Compile as Compile$1 } from "typebox/compile";
+import { Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
-  Decode: typeof Decode$2;
+  Decode: typeof Decode$1;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -20,12 +21,12 @@ interface TypeboxModule {
   coerceBody: typeof coerceBody$1;
   hasTypes: typeof hasTypes$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$2;
+  Intersect: typeof Intersect$1;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
 }
 declare let Compile: typeof Compile$1;
-declare let Decode: typeof Decode$2;
+declare let Decode: typeof Decode$1;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -38,7 +39,7 @@ declare let coerceStringToStructure: typeof coerceStringToStructure$1;
 declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$2;
+declare let Intersect: typeof Intersect$1;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare function useTypebox(mod: TypeboxModule): void;

package/dist/type/coerce.d.ts

@@ -36,8 +36,26 @@ 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): TSchema | BaseSchema;
+declare function applyCoercions(schema: BaseSchema | TSchema, coerces: CoerceOption[] | undefined): BaseSchema | TSchema;
+interface CoerceLeaf {
+  e: number;
+  c?: Record<string, unknown>;
+  o?: unknown;
+}
+interface CoerceObjStr {
+  os: number;
+  o?: unknown;
+}
+type CoerceNode = CoerceLeaf | CoerceObjStr | CoercePlan;
+interface CoercePlan {
+  p?: Record<string, CoerceNode>;
+  i?: CoerceNode;
+}
+declare function captureCoercePlan(original: any, coerced: any): CoercePlan | null;
+declare function buildCoercedFromPlan(original: any, plan: CoercePlan): any;
+/** @internal test isolation */
+declare function clearCoerceLeafCache(): void;
 declare function nonAdditionalProperties(schema: BaseSchema | TSchema): BaseSchema;
 declare function deferCoercions(): void;
 //#endregion
-export { CoerceOption, applyCoercions, coerce, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, deferCoercions, nonAdditionalProperties };
+export { CoerceLeaf, CoerceObjStr, CoerceOption, CoercePlan, applyCoercions, buildCoercedFromPlan, captureCoercePlan, clearCoerceLeafCache, coerce, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, deferCoercions, nonAdditionalProperties };

package/dist/type/coerce.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils = require('../utils.js');
 const require_type_constants = require('./constants.js');
 const require_type_elysia_array_string = require('./elysia/array-string.js');
 const require_type_elysia_object_string = require('./elysia/object-string.js');
@@ -235,6 +236,112 @@ function applyCoercions(schema, coerces) {
 	if (coerces) for (const coercion of coerces) schema = coerce(schema, coercion[0], coercion[1]);
 	return schema;
 }
+const COERCE_LEAF_CTOR = {
+	[require_type_constants.ELYSIA_TYPES.Numeric]: require_type_elysia_numeric.Numeric,
+	[require_type_constants.ELYSIA_TYPES.Integer]: require_type_elysia_integer_string.IntegerString,
+	[require_type_constants.ELYSIA_TYPES.BooleanString]: require_type_elysia_boolean_string.BooleanString
+};
+const isCoerceLeaf = (x) => typeof x.e === "number";
+const isCoerceObjStr = (x) => typeof x.os === "number";
+function captureCoercePlan(original, coerced) {
+	let bakeable = true;
+	let any = false;
+	const walk = (o, c) => {
+		if (o === c || !c || typeof c !== "object") return null;
+		const ely = c["~elyTyp"];
+		if (ely === require_type_constants.ELYSIA_TYPES.ObjectString && (!o || o["~elyTyp"] !== ely)) {
+			any = true;
+			const site = { os: ely };
+			if (o && "~optional" in o) site.o = o["~optional"];
+			return site;
+		}
+		if (ely === require_type_constants.ELYSIA_TYPES.ArrayString) {
+			bakeable = false;
+			return null;
+		}
+		if (ely && COERCE_LEAF_CTOR[ely] && (!o || o["~elyTyp"] !== ely)) {
+			any = true;
+			const leaf = { e: ely };
+			if (o) {
+				const { type, ...rest } = o;
+				if (Object.keys(rest).length) leaf.c = rest;
+				if ("~optional" in o) leaf.o = o["~optional"];
+			}
+			return leaf;
+		}
+		if (Array.isArray(c.anyOf) && c.anyOf.some((b, i) => b !== o?.anyOf?.[i]) || Array.isArray(c.allOf) && c.allOf.some((b, i) => b !== o?.allOf?.[i]) || Array.isArray(c.oneOf) && c.oneOf.some((b, i) => b !== o?.oneOf?.[i]) || Array.isArray(c.items) && c.items.some((b, i) => b !== o?.items?.[i]) || c.not && c.not !== o?.not || c.additionalProperties && typeof c.additionalProperties === "object" && c.additionalProperties !== o?.additionalProperties) {
+			bakeable = false;
+			return null;
+		}
+		const plan = require_utils.nullObject();
+		if (c.properties && o?.properties) for (const k in c.properties) {
+			const sub = walk(o.properties[k], c.properties[k]);
+			if (sub) (plan.p ??= require_utils.nullObject())[k] = sub;
+		}
+		if (c.items && !Array.isArray(c.items) && o?.items && !Array.isArray(o.items)) {
+			const sub = walk(o.items, c.items);
+			if (sub) plan.i = sub;
+		}
+		return plan.p || plan.i ? plan : null;
+	};
+	const plan = walk(original, coerced);
+	if (!bakeable || !any || !plan || isCoerceLeaf(plan) || isCoerceObjStr(plan)) return null;
+	if (!jsonSafe(plan)) return null;
+	return plan;
+}
+function jsonSafe(value) {
+	if (value === null) return true;
+	const t = typeof value;
+	if (t === "number") return Number.isFinite(value);
+	if (t === "string" || t === "boolean") return true;
+	if (t !== "object") return false;
+	if (Array.isArray(value)) return value.every(jsonSafe);
+	for (const k in value) if (!jsonSafe(value[k])) return false;
+	return true;
+}
+function rebuildObjStr(original, site) {
+	const { type, ...rest } = original;
+	const node = site.os === require_type_constants.ELYSIA_TYPES.ObjectString ? toObjectString(rest) : toArrayString(rest);
+	if ("o" in site) return Object.defineProperty(node, "~optional", {
+		value: site.o,
+		enumerable: false
+	});
+	return node;
+}
+const buildCoerceNode = (original, node) => isCoerceLeaf(node) ? coerceLeaf(node) : isCoerceObjStr(node) ? rebuildObjStr(original, node) : buildCoercedFromPlan(original, node);
+const coerceLeafCache = /* @__PURE__ */ new Map();
+function coerceLeaf(leaf) {
+	const key = leaf.e + (leaf.c ? JSON.stringify(leaf.c) : "");
+	let node = coerceLeafCache.get(key);
+	if (node === void 0) {
+		node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
+		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) {
+	const out = Object.create(Object.getPrototypeOf(original));
+	for (const k in original) out[k] = original[k];
+	for (const s of Object.getOwnPropertyNames(original)) {
+		const d = Object.getOwnPropertyDescriptor(original, s);
+		if (!d.enumerable) Object.defineProperty(out, s, d);
+	}
+	if (plan.p) {
+		const props = { ...original.properties };
+		for (const k in plan.p) props[k] = buildCoerceNode(original.properties[k], plan.p[k]);
+		out.properties = props;
+	}
+	if (plan.i) out.items = buildCoerceNode(original.items, plan.i);
+	return out;
+}
+/** @internal test isolation */
+function clearCoerceLeafCache() {
+	coerceLeafCache.clear();
+}
 const noEnumerable = { enumerable: false };
 function cloneNode(node, out) {
 	if (out !== node) return out;
@@ -354,6 +461,9 @@ function deferCoercions() {
 
 //#endregion
 exports.applyCoercions = applyCoercions;
+exports.buildCoercedFromPlan = buildCoercedFromPlan;
+exports.captureCoercePlan = captureCoercePlan;
+exports.clearCoerceLeafCache = clearCoerceLeafCache;
 exports.coerce = coerce;
 exports.coerceBody = coerceBody;
 exports.coerceFormData = coerceFormData;

package/dist/type/coerce.mjs

@@ -1,4 +1,5 @@
-import { primitiveElysiaTypes } from "./constants.mjs";
+import { nullObject } from "../utils.mjs";
+import { ELYSIA_TYPES, primitiveElysiaTypes } from "./constants.mjs";
 import { ArrayString } from "./elysia/array-string.mjs";
 import { ObjectString } from "./elysia/object-string.mjs";
 import { Numeric } from "./elysia/numeric.mjs";
@@ -234,6 +235,112 @@ function applyCoercions(schema, coerces) {
 	if (coerces) for (const coercion of coerces) schema = coerce(schema, coercion[0], coercion[1]);
 	return schema;
 }
+const COERCE_LEAF_CTOR = {
+	[ELYSIA_TYPES.Numeric]: Numeric,
+	[ELYSIA_TYPES.Integer]: IntegerString,
+	[ELYSIA_TYPES.BooleanString]: BooleanString
+};
+const isCoerceLeaf = (x) => typeof x.e === "number";
+const isCoerceObjStr = (x) => typeof x.os === "number";
+function captureCoercePlan(original, coerced) {
+	let bakeable = true;
+	let any = false;
+	const walk = (o, c) => {
+		if (o === c || !c || typeof c !== "object") return null;
+		const ely = c["~elyTyp"];
+		if (ely === ELYSIA_TYPES.ObjectString && (!o || o["~elyTyp"] !== ely)) {
+			any = true;
+			const site = { os: ely };
+			if (o && "~optional" in o) site.o = o["~optional"];
+			return site;
+		}
+		if (ely === ELYSIA_TYPES.ArrayString) {
+			bakeable = false;
+			return null;
+		}
+		if (ely && COERCE_LEAF_CTOR[ely] && (!o || o["~elyTyp"] !== ely)) {
+			any = true;
+			const leaf = { e: ely };
+			if (o) {
+				const { type, ...rest } = o;
+				if (Object.keys(rest).length) leaf.c = rest;
+				if ("~optional" in o) leaf.o = o["~optional"];
+			}
+			return leaf;
+		}
+		if (Array.isArray(c.anyOf) && c.anyOf.some((b, i) => b !== o?.anyOf?.[i]) || Array.isArray(c.allOf) && c.allOf.some((b, i) => b !== o?.allOf?.[i]) || Array.isArray(c.oneOf) && c.oneOf.some((b, i) => b !== o?.oneOf?.[i]) || Array.isArray(c.items) && c.items.some((b, i) => b !== o?.items?.[i]) || c.not && c.not !== o?.not || c.additionalProperties && typeof c.additionalProperties === "object" && c.additionalProperties !== o?.additionalProperties) {
+			bakeable = false;
+			return null;
+		}
+		const plan = nullObject();
+		if (c.properties && o?.properties) for (const k in c.properties) {
+			const sub = walk(o.properties[k], c.properties[k]);
+			if (sub) (plan.p ??= nullObject())[k] = sub;
+		}
+		if (c.items && !Array.isArray(c.items) && o?.items && !Array.isArray(o.items)) {
+			const sub = walk(o.items, c.items);
+			if (sub) plan.i = sub;
+		}
+		return plan.p || plan.i ? plan : null;
+	};
+	const plan = walk(original, coerced);
+	if (!bakeable || !any || !plan || isCoerceLeaf(plan) || isCoerceObjStr(plan)) return null;
+	if (!jsonSafe(plan)) return null;
+	return plan;
+}
+function jsonSafe(value) {
+	if (value === null) return true;
+	const t = typeof value;
+	if (t === "number") return Number.isFinite(value);
+	if (t === "string" || t === "boolean") return true;
+	if (t !== "object") return false;
+	if (Array.isArray(value)) return value.every(jsonSafe);
+	for (const k in value) if (!jsonSafe(value[k])) return false;
+	return true;
+}
+function rebuildObjStr(original, site) {
+	const { type, ...rest } = original;
+	const node = site.os === ELYSIA_TYPES.ObjectString ? toObjectString(rest) : toArrayString(rest);
+	if ("o" in site) return Object.defineProperty(node, "~optional", {
+		value: site.o,
+		enumerable: false
+	});
+	return node;
+}
+const buildCoerceNode = (original, node) => isCoerceLeaf(node) ? coerceLeaf(node) : isCoerceObjStr(node) ? rebuildObjStr(original, node) : buildCoercedFromPlan(original, node);
+const coerceLeafCache = /* @__PURE__ */ new Map();
+function coerceLeaf(leaf) {
+	const key = leaf.e + (leaf.c ? JSON.stringify(leaf.c) : "");
+	let node = coerceLeafCache.get(key);
+	if (node === void 0) {
+		node = COERCE_LEAF_CTOR[leaf.e](leaf.c);
+		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) {
+	const out = Object.create(Object.getPrototypeOf(original));
+	for (const k in original) out[k] = original[k];
+	for (const s of Object.getOwnPropertyNames(original)) {
+		const d = Object.getOwnPropertyDescriptor(original, s);
+		if (!d.enumerable) Object.defineProperty(out, s, d);
+	}
+	if (plan.p) {
+		const props = { ...original.properties };
+		for (const k in plan.p) props[k] = buildCoerceNode(original.properties[k], plan.p[k]);
+		out.properties = props;
+	}
+	if (plan.i) out.items = buildCoerceNode(original.items, plan.i);
+	return out;
+}
+/** @internal test isolation */
+function clearCoerceLeafCache() {
+	coerceLeafCache.clear();
+}
 const noEnumerable = { enumerable: false };
 function cloneNode(node, out) {
 	if (out !== node) return out;
@@ -352,4 +459,4 @@ function deferCoercions() {
 }
 
 //#endregion
-export { applyCoercions, coerce, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, deferCoercions, nonAdditionalProperties };
+export { applyCoercions, buildCoercedFromPlan, captureCoercePlan, clearCoerceLeafCache, coerce, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure, deferCoercions, nonAdditionalProperties };

package/dist/type/compat.js

@@ -3,7 +3,8 @@ const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_type_bridge = require('./bridge.js');
 const require_type_coerce = require('./coerce.js');
 const require_type_utils = require('./utils.js');
-const require_type_validator = require('./validator.js');
+const require_type_validator_validator_cache = require('./validator/validator-cache.js');
+const require_type_validator_index = require('./validator/index.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
 let typebox_compile = require("typebox/compile");
 let typebox_type = require("typebox/type");
@@ -20,8 +21,8 @@ function setupTypebox() {
 		Compile: typebox_compile.Compile,
 		Decode: typebox_value.Decode,
 		applyCoercions: require_type_coerce.applyCoercions,
-		TypeBoxValidator: require_type_validator.TypeBoxValidator,
-		TypeBoxValidatorCache: require_type_validator.TypeBoxValidatorCache,
+		TypeBoxValidator: require_type_validator_index.TypeBoxValidator,
+		TypeBoxValidatorCache: require_type_validator_validator_cache.TypeBoxValidatorCache,
 		coerceFormData: require_type_coerce.coerceFormData,
 		coerceQuery: require_type_coerce.coerceQuery,
 		coerceRoot: require_type_coerce.coerceRoot,

package/dist/type/compat.mjs

@@ -1,7 +1,8 @@
 import { useTypebox } from "./bridge.mjs";
 import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure } from "./coerce.mjs";
 import { hasTypes } from "./utils.mjs";
-import { TypeBoxValidator, TypeBoxValidatorCache } from "./validator.mjs";
+import { TypeBoxValidatorCache } from "./validator/validator-cache.mjs";
+import { TypeBoxValidator } from "./validator/index.mjs";
 import { Intersect as Intersect$1 } from "./elysia/intersect.mjs";
 import { Compile } from "typebox/compile";
 import { Ref } from "typebox/type";

package/dist/type/constants.d.ts

@@ -17,7 +17,7 @@ declare const ELYSIA_TYPES: {
   readonly NoValidate: 15;
 };
 type ELYSIA_TYPES = typeof ELYSIA_TYPES;
-declare const primitiveElysiaTypes: Set<1 | 2 | 3 | 6 | 14 | 13 | 11 | 10>;
+declare const primitiveElysiaTypes: Set<1 | 2 | 3 | 6 | 10 | 11 | 13 | 14>;
 declare const noEnumerable: {
   readonly enumerable: false;
 };

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

@@ -13,7 +13,7 @@ let StringifiedBoolean;
 let emptyBooleanString;
 function BooleanString(property) {
 	StringifiedBoolean ??= (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => value === "true" || value === "false", () => "must be boolean"), (value) => value === "true" ? true : false);
-	if (!property || require_utils.isEmpty(property)) return emptyBooleanString ??= require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.BooleanString, require_type_elysia_union.Union([require_type_elysia_boolean.BooleanType(), StringifiedBoolean]));
+	if (!property || require_utils.isEmpty(property)) return emptyBooleanString ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.BooleanString, require_type_elysia_union.Union([require_type_elysia_boolean.BooleanType(), StringifiedBoolean])));
 	const [, meta] = require_type_elysia_utils.getMeta(property);
 	const boolean = require_type_elysia_boolean.BooleanType(property);
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.BooleanString, require_type_elysia_union.Union([boolean, StringifiedBoolean], meta));

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

@@ -11,7 +11,7 @@ let StringifiedBoolean;
 let emptyBooleanString;
 function BooleanString(property) {
 	StringifiedBoolean ??= Decode(Refine(StringType(), (value) => value === "true" || value === "false", () => "must be boolean"), (value) => value === "true" ? true : false);
-	if (!property || isEmpty(property)) return emptyBooleanString ??= elyType(ELYSIA_TYPES.BooleanString, Union([BooleanType(), StringifiedBoolean]));
+	if (!property || isEmpty(property)) return emptyBooleanString ??= Object.freeze(elyType(ELYSIA_TYPES.BooleanString, Union([BooleanType(), StringifiedBoolean])));
 	const [, meta] = getMeta(property);
 	const boolean = BooleanType(property);
 	return elyType(ELYSIA_TYPES.BooleanString, Union([boolean, StringifiedBoolean], meta));

package/dist/type/elysia/file-type.js

@@ -16,7 +16,7 @@ let warnedNoFileTypeDetector = false;
 function warnNoFileTypeDetector() {
 	if (warnedNoFileTypeDetector) return;
 	warnedNoFileTypeDetector = true;
-	console.warn("[Elysia] Attempt to validate file type without a file type detector, only the file's reported mime type is checked which can be spoofed. This may lead to security risks. We recommend registering a detector with `setFileTypeDetector`, eg. `setFileTypeDetector(fileTypeFromBlob)` using the 'file-type' package.");
+	console.warn("[Elysia] Attempt to validate file type without a file type detector, please set one using `setFileTypeDetector`");
 }
 async function fileType(file, type) {
 	if (Array.isArray(file)) return (await Promise.all(file.map((f) => fileType(f, type)))).every(Boolean);

package/dist/type/elysia/file-type.mjs

@@ -14,7 +14,7 @@ let warnedNoFileTypeDetector = false;
 function warnNoFileTypeDetector() {
 	if (warnedNoFileTypeDetector) return;
 	warnedNoFileTypeDetector = true;
-	console.warn("[Elysia] Attempt to validate file type without a file type detector, only the file's reported mime type is checked which can be spoofed. This may lead to security risks. We recommend registering a detector with `setFileTypeDetector`, eg. `setFileTypeDetector(fileTypeFromBlob)` using the 'file-type' package.");
+	console.warn("[Elysia] Attempt to validate file type without a file type detector, please set one using `setFileTypeDetector`");
 }
 async function fileType(file, type) {
 	if (Array.isArray(file)) return (await Promise.all(file.map((f) => fileType(f, type)))).every(Boolean);