elysia 2.0.0-exp.27 → 2.0.0-exp.29

package/dist/base.d.ts

@@ -1,8 +1,8 @@
 import { ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
+import { AnySchema } from "./type/types.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
 import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
-import { AnySchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { WSHandlerResponse, WSLocalHook, WSMessageHandler } from "./ws/types.js";

package/dist/base.js

@@ -766,27 +766,29 @@ var Elysia = class Elysia {
 		this.#routerBuilt = false;
 		this.#buildRouter();
 	}
-	#add(method, path, fn, hook) {
+	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = require_utils.joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		const handler = hasHook ? fn : hookOrFn;
+		const hook = hasHook ? hookOrFn : void 0;
 		const appHook = this["~hookChain"];
 		(this.#history ??= []).push(appHook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook,
 			appHook
 		] : hook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook
 		] : [
 			method,
 			path,
-			fn,
+			handler,
 			this
 		]);
 		this.#cachedRoutes = void 0;
@@ -832,38 +834,37 @@ var Elysia = class Elysia {
 	* Registered reusable models (via `.model()`), keyed by name.
 	*/
 	get models() {
-		return this["~ext"]?.models ?? {};
+		return this["~ext"]?.models ?? require_utils.nullObject();
 	}
 	Ref(key) {
 		return require_type_bridge.Ref(key);
 	}
 	get(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.GET, path, hookOrFn) : this.#add(require_constants.MethodMap.GET, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.GET, path, hookOrFn, fn);
 	}
 	post(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.POST, path, hookOrFn) : this.#add(require_constants.MethodMap.POST, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.POST, path, hookOrFn, fn);
 	}
 	put(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.PUT, path, hookOrFn) : this.#add(require_constants.MethodMap.PUT, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.PUT, path, hookOrFn, fn);
 	}
 	patch(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.PATCH, path, hookOrFn) : this.#add(require_constants.MethodMap.PATCH, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.PATCH, path, hookOrFn, fn);
 	}
 	delete(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.DELETE, path, hookOrFn) : this.#add(require_constants.MethodMap.DELETE, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.DELETE, path, hookOrFn, fn);
 	}
 	options(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.OPTIONS, path, hookOrFn) : this.#add(require_constants.MethodMap.OPTIONS, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.OPTIONS, path, hookOrFn, fn);
 	}
 	head(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.HEAD, path, hookOrFn) : this.#add(require_constants.MethodMap.HEAD, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.HEAD, path, hookOrFn, fn);
 	}
 	method(method, path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(method, path, hookOrFn) : this.#add(method, path, fn, hookOrFn);
+		return this.#add(method, path, hookOrFn, fn);
 	}
 	all(path, hookOrFn, fn) {
-		if (fn === void 0) this.#add("*", path, hookOrFn);
-		else this.#add("*", path, fn, hookOrFn);
+		this.#add("*", path, hookOrFn, fn);
 		return this;
 	}
 	ws(path, optionsOrHandler, handler) {
@@ -879,7 +880,7 @@ var Elysia = class Elysia {
 			opts = require_utils.nullObject();
 			opts.message = optionsOrHandler;
 		} else opts = optionsOrHandler;
-		this.#add("WS", path, void 0, opts);
+		this.#add("WS", path, opts, void 0, true);
 		return this;
 	}
 	mount(path, handleOrConfig, config) {
@@ -943,7 +944,12 @@ var Elysia = class Elysia {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(this.#history.length);
 		if (immediate) {
-			const handler = require_compile_handler_index.compileHandler(this.#history[index], this, precomputedStatic);
+			let handler;
+			try {
+				handler = require_compile_handler_index.compileHandler(this.#history[index], this, precomputedStatic);
+			} catch (error) {
+				throw new Error(`[Elysia] Failed to compile route ${require_utils.mapMethodBack(route[0])} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+			}
 			compiled[index] = handler;
 			this.#saveHandler(route[0], route[1], handler);
 			return handler;
@@ -953,7 +959,12 @@ var Elysia = class Elysia {
 	#jitHandler(index, route, precomputedStatic, aliases) {
 		return (context) => {
 			if (this.#compiled[index]) return this.#compiled[index](context);
-			const handler = require_compile_handler_index.compileHandler(this.#history[index], this, precomputedStatic);
+			let handler;
+			try {
+				handler = require_compile_handler_index.compileHandler(this.#history[index], this, precomputedStatic);
+			} catch (error) {
+				throw new Error(`[Elysia] Failed to compile route ${require_utils.mapMethodBack(route[0])} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+			}
 			this.#compiled[index] = handler;
 			if (aliases) {
 				this.#initMap();
@@ -999,6 +1010,58 @@ var Elysia = class Elysia {
 			return r instanceof Promise ? r.then(Elysia.#toHeadResponse) : Elysia.#toHeadResponse(r);
 		});
 	}
+	#chainRefMemo;
+	static #slotHasString(h) {
+		if (!h || typeof h !== "object") return false;
+		for (const key of require_utils.schemaProperties) {
+			const v = h[key];
+			if (typeof v === "string") return true;
+			if (key === "response" && v && typeof v === "object") {
+				const record = v;
+				if ("~kind" in record || "~elyAcl" in record || "~standard" in record) continue;
+				for (const status in record) if (typeof record[status] === "string") return true;
+			}
+		}
+		return false;
+	}
+	static #hookHasString(h) {
+		if (Elysia.#slotHasString(h)) return true;
+		const schemas = h?.schemas;
+		if (Array.isArray(schemas)) {
+			for (let s = 0; s < schemas.length; s++) if (Elysia.#slotHasString(schemas[s])) return true;
+		}
+		return false;
+	}
+	#chainHasModelRef(start) {
+		if (!start) return false;
+		const memo = this.#chainRefMemo ??= /* @__PURE__ */ new WeakMap();
+		const cached = memo.get(start);
+		if (cached !== void 0) return cached;
+		let found = false;
+		const stack = [start];
+		while (stack.length) {
+			const node = stack.pop();
+			if (!node) continue;
+			if ("combine" in node) {
+				stack.push(node.combine);
+				stack.push(node.over);
+			} else {
+				if (Elysia.#hookHasString(node.added)) {
+					found = true;
+					break;
+				}
+				stack.push(node.parent);
+			}
+		}
+		memo.set(start, found);
+		return found;
+	}
+	#routeMayHaveModelRef(route) {
+		if (this["~ext"]?.macro || this["~scopeChildren"]) return true;
+		if (require_compile_handler_index.localMacroRoot(route[7] ?? route[3] ?? this, this)["~ext"]?.macro) return true;
+		if (Elysia.#hookHasString(route[4])) return true;
+		return this.#chainHasModelRef(route[5]) || this.#chainHasModelRef(route[6]) || this.#chainHasModelRef(this["~hookChain"]);
+	}
 	#assertRouteModelRefs(route, method) {
 		const models = this["~ext"]?.models;
 		const path = route[1];
@@ -1039,7 +1102,7 @@ var Elysia = class Elysia {
 			const route = this.#history[i];
 			const m = route[0] === "WS" ? "WS" : require_utils.mapMethodBack(route[0]);
 			const key = m + " " + route[1];
-			this.#assertRouteModelRefs(route, m);
+			if (this.#routeMayHaveModelRef(route)) this.#assertRouteModelRefs(route, m);
 			if (seen.has(key)) {
 				hasDuplicate = true;
 				if (!require_error.isProduction()) {

package/dist/base.mjs

@@ -763,27 +763,29 @@ var Elysia = class Elysia {
 		this.#routerBuilt = false;
 		this.#buildRouter();
 	}
-	#add(method, path, fn, hook) {
+	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		const handler = hasHook ? fn : hookOrFn;
+		const hook = hasHook ? hookOrFn : void 0;
 		const appHook = this["~hookChain"];
 		(this.#history ??= []).push(appHook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook,
 			appHook
 		] : hook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook
 		] : [
 			method,
 			path,
-			fn,
+			handler,
 			this
 		]);
 		this.#cachedRoutes = void 0;
@@ -829,38 +831,37 @@ var Elysia = class Elysia {
 	* Registered reusable models (via `.model()`), keyed by name.
 	*/
 	get models() {
-		return this["~ext"]?.models ?? {};
+		return this["~ext"]?.models ?? nullObject();
 	}
 	Ref(key) {
 		return Ref(key);
 	}
 	get(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.GET, path, hookOrFn) : this.#add(MethodMap.GET, path, fn, hookOrFn);
+		return this.#add(MethodMap.GET, path, hookOrFn, fn);
 	}
 	post(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.POST, path, hookOrFn) : this.#add(MethodMap.POST, path, fn, hookOrFn);
+		return this.#add(MethodMap.POST, path, hookOrFn, fn);
 	}
 	put(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.PUT, path, hookOrFn) : this.#add(MethodMap.PUT, path, fn, hookOrFn);
+		return this.#add(MethodMap.PUT, path, hookOrFn, fn);
 	}
 	patch(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.PATCH, path, hookOrFn) : this.#add(MethodMap.PATCH, path, fn, hookOrFn);
+		return this.#add(MethodMap.PATCH, path, hookOrFn, fn);
 	}
 	delete(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.DELETE, path, hookOrFn) : this.#add(MethodMap.DELETE, path, fn, hookOrFn);
+		return this.#add(MethodMap.DELETE, path, hookOrFn, fn);
 	}
 	options(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.OPTIONS, path, hookOrFn) : this.#add(MethodMap.OPTIONS, path, fn, hookOrFn);
+		return this.#add(MethodMap.OPTIONS, path, hookOrFn, fn);
 	}
 	head(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.HEAD, path, hookOrFn) : this.#add(MethodMap.HEAD, path, fn, hookOrFn);
+		return this.#add(MethodMap.HEAD, path, hookOrFn, fn);
 	}
 	method(method, path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(method, path, hookOrFn) : this.#add(method, path, fn, hookOrFn);
+		return this.#add(method, path, hookOrFn, fn);
 	}
 	all(path, hookOrFn, fn) {
-		if (fn === void 0) this.#add("*", path, hookOrFn);
-		else this.#add("*", path, fn, hookOrFn);
+		this.#add("*", path, hookOrFn, fn);
 		return this;
 	}
 	ws(path, optionsOrHandler, handler) {
@@ -876,7 +877,7 @@ var Elysia = class Elysia {
 			opts = nullObject();
 			opts.message = optionsOrHandler;
 		} else opts = optionsOrHandler;
-		this.#add("WS", path, void 0, opts);
+		this.#add("WS", path, opts, void 0, true);
 		return this;
 	}
 	mount(path, handleOrConfig, config) {
@@ -940,7 +941,12 @@ var Elysia = class Elysia {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(this.#history.length);
 		if (immediate) {
-			const handler = compileHandler(this.#history[index], this, precomputedStatic);
+			let handler;
+			try {
+				handler = compileHandler(this.#history[index], this, precomputedStatic);
+			} catch (error) {
+				throw new Error(`[Elysia] Failed to compile route ${mapMethodBack(route[0])} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+			}
 			compiled[index] = handler;
 			this.#saveHandler(route[0], route[1], handler);
 			return handler;
@@ -950,7 +956,12 @@ var Elysia = class Elysia {
 	#jitHandler(index, route, precomputedStatic, aliases) {
 		return (context) => {
 			if (this.#compiled[index]) return this.#compiled[index](context);
-			const handler = compileHandler(this.#history[index], this, precomputedStatic);
+			let handler;
+			try {
+				handler = compileHandler(this.#history[index], this, precomputedStatic);
+			} catch (error) {
+				throw new Error(`[Elysia] Failed to compile route ${mapMethodBack(route[0])} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+			}
 			this.#compiled[index] = handler;
 			if (aliases) {
 				this.#initMap();
@@ -996,6 +1007,58 @@ var Elysia = class Elysia {
 			return r instanceof Promise ? r.then(Elysia.#toHeadResponse) : Elysia.#toHeadResponse(r);
 		});
 	}
+	#chainRefMemo;
+	static #slotHasString(h) {
+		if (!h || typeof h !== "object") return false;
+		for (const key of schemaProperties) {
+			const v = h[key];
+			if (typeof v === "string") return true;
+			if (key === "response" && v && typeof v === "object") {
+				const record = v;
+				if ("~kind" in record || "~elyAcl" in record || "~standard" in record) continue;
+				for (const status in record) if (typeof record[status] === "string") return true;
+			}
+		}
+		return false;
+	}
+	static #hookHasString(h) {
+		if (Elysia.#slotHasString(h)) return true;
+		const schemas = h?.schemas;
+		if (Array.isArray(schemas)) {
+			for (let s = 0; s < schemas.length; s++) if (Elysia.#slotHasString(schemas[s])) return true;
+		}
+		return false;
+	}
+	#chainHasModelRef(start) {
+		if (!start) return false;
+		const memo = this.#chainRefMemo ??= /* @__PURE__ */ new WeakMap();
+		const cached = memo.get(start);
+		if (cached !== void 0) return cached;
+		let found = false;
+		const stack = [start];
+		while (stack.length) {
+			const node = stack.pop();
+			if (!node) continue;
+			if ("combine" in node) {
+				stack.push(node.combine);
+				stack.push(node.over);
+			} else {
+				if (Elysia.#hookHasString(node.added)) {
+					found = true;
+					break;
+				}
+				stack.push(node.parent);
+			}
+		}
+		memo.set(start, found);
+		return found;
+	}
+	#routeMayHaveModelRef(route) {
+		if (this["~ext"]?.macro || this["~scopeChildren"]) return true;
+		if (localMacroRoot(route[7] ?? route[3] ?? this, this)["~ext"]?.macro) return true;
+		if (Elysia.#hookHasString(route[4])) return true;
+		return this.#chainHasModelRef(route[5]) || this.#chainHasModelRef(route[6]) || this.#chainHasModelRef(this["~hookChain"]);
+	}
 	#assertRouteModelRefs(route, method) {
 		const models = this["~ext"]?.models;
 		const path = route[1];
@@ -1036,7 +1099,7 @@ var Elysia = class Elysia {
 			const route = this.#history[i];
 			const m = route[0] === "WS" ? "WS" : mapMethodBack(route[0]);
 			const key = m + " " + route[1];
-			this.#assertRouteModelRefs(route, m);
+			if (this.#routeMayHaveModelRef(route)) this.#assertRouteModelRefs(route, m);
 			if (seen.has(key)) {
 				hasDuplicate = true;
 				if (!isProduction()) {

package/dist/compile/aot.d.ts

@@ -1,5 +1,4 @@
-import { CoercePlan } from "../type/coerce.js";
-
+import { CoercePlan } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
 type ValidatorSlot = 'body' | 'query' | 'params' | 'headers' | 'cookie' | `response:${number}`;
 type FrozenCheckFactory = (External: unknown) => (value: unknown) => boolean;
@@ -115,6 +114,7 @@ declare const Source: {
   readonly mirrorFactory: (source: string, hasExternals: boolean) => string;
   readonly bothFactory: (identifier: string, checkDefs: string, checkValue: string, mirrorSource: string, mirrorHasExternals: boolean) => string;
 };
+declare function collectMirrorUnions(schema: any, out?: unknown[][]): unknown[][];
 declare function instantiateFrozenMirror(frozen: FrozenMirror, schema: unknown): (value: unknown) => unknown;
 declare function instantiateFrozenDecodeMirror(frozen: FrozenMirror, schema: unknown, dir?: 'decode' | 'encode'): (value: unknown) => unknown;
 declare const instantiateFrozenEncodeMirror: (frozen: FrozenMirror, schema: unknown) => ((value: unknown) => unknown);
@@ -123,6 +123,20 @@ declare function instantiateFrozenBoth(frozen: FrozenValidator, checkSchema: unk
   check?: (value: unknown) => boolean;
   clean?: (value: unknown) => unknown;
 };
+interface StringCodecNode {
+  inner: any;
+  codec: any;
+  open: number;
+}
+declare function collectStringCodecNodes(schema: any, out?: StringCodecNode[]): StringCodecNode[];
+/**
+ * Overwrite every ObjectString/ArrayString node's `~refine[0].check` and
+ * `~codec.decode` with the baked `ic` closures. After this runs, the node no
+ * longer calls the constructor's live `typebox/value` Check/Decode
+ *
+ * Iterate in reverse so nested codecs reconstruct bottom-up.
+ */
+declare function reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
 /**
  * verify that mirror unions can be reconstructed in build time
  *
@@ -216,4 +230,4 @@ declare const Capture: {
  */
 declare const resetCaptureLifecycleForTests: () => void;
 //#endregion
-export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledSnapshot, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, resetCaptureLifecycleForTests };
+export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledSnapshot, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, StringCodecNode, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs, resetCaptureLifecycleForTests };

package/dist/compile/aot.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../utils.js');
+const require_type_constants = require('../type/constants.js');
 const require_universal_env = require('../universal/env.js');
 
 //#region src/compile/aot.ts
@@ -201,6 +202,53 @@ const EMPTY_EXTERNALS = Object.freeze([]);
 function instantiateFrozenBoth(frozen, checkSchema, mirrorSchema) {
 	return frozen.cm(frozen.e ? collectExternals(checkSchema) : EMPTY_EXTERNALS, frozen.u ? { unions: buildUnions(frozen.u, mirrorSchema) } : void 0);
 }
+function collectStringCodecNodes(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	const ely = schema["~elyTyp"];
+	if (ely === require_type_constants.ELYSIA_TYPES.ObjectString || ely === require_type_constants.ELYSIA_TYPES.ArrayString) {
+		const inner = schema.anyOf?.[0];
+		const codec = schema.anyOf?.[1];
+		if (inner && codec?.["~codec"] && codec["~refine"]) out.push({
+			inner,
+			codec,
+			open: ely === require_type_constants.ELYSIA_TYPES.ObjectString ? 123 : 91
+		});
+	}
+	if (schema.properties) for (const k in schema.properties) collectStringCodecNodes(schema.properties[k], out);
+	const items = schema.items;
+	if (Array.isArray(items)) for (const it of items) collectStringCodecNodes(it, out);
+	else if (items) collectStringCodecNodes(items, out);
+	if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectStringCodecNodes(b, out);
+	return out;
+}
+/**
+* Overwrite every ObjectString/ArrayString node's `~refine[0].check` and
+* `~codec.decode` with the baked `ic` closures. After this runs, the node no
+* longer calls the constructor's live `typebox/value` Check/Decode
+*
+* Iterate in reverse so nested codecs reconstruct bottom-up.
+*/
+function reconstructInnerCodecs(ic, schema) {
+	const nodes = collectStringCodecNodes(schema);
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const entry = ic[i];
+		const node = nodes[i];
+		if (!entry || !node) continue;
+		const innerSchema = node.inner;
+		const innerCheck = entry.c(entry.e ? collectExternals(innerSchema) : []);
+		const innerMirror = entry.d.x ? instantiateFrozenDecodeMirror(entry.d, innerSchema) : entry.d.s;
+		const open = entry.o;
+		node.codec["~refine"][0].check = (v) => {
+			if (v.charCodeAt(0) !== open) return false;
+			try {
+				return innerCheck(JSON.parse(v));
+			} catch {
+				return false;
+			}
+		};
+		node.codec["~codec"].decode = (v) => innerMirror(JSON.parse(v));
+	}
+}
 /**
 * verify that mirror unions can be reconstructed in build time
 *
@@ -299,6 +347,8 @@ exports.EMPTY_EXTERNALS = EMPTY_EXTERNALS;
 exports.Source = Source;
 exports.beginValidatorCapture = beginValidatorCapture;
 exports.collectExternals = collectExternals;
+exports.collectMirrorUnions = collectMirrorUnions;
+exports.collectStringCodecNodes = collectStringCodecNodes;
 exports.endHandlerCapture = endHandlerCapture;
 exports.endValidatorCapture = endValidatorCapture;
 exports.externalsMatch = externalsMatch;
@@ -307,4 +357,5 @@ exports.instantiateFrozenDecodeMirror = instantiateFrozenDecodeMirror;
 exports.instantiateFrozenEncodeMirror = instantiateFrozenEncodeMirror;
 exports.instantiateFrozenMirror = instantiateFrozenMirror;
 exports.reconstructCheck = reconstructCheck;
+exports.reconstructInnerCodecs = reconstructInnerCodecs;
 exports.resetCaptureLifecycleForTests = resetCaptureLifecycleForTests;

package/dist/compile/aot.mjs

@@ -1,4 +1,5 @@
 import { nullObject } from "../utils.mjs";
+import { ELYSIA_TYPES } from "../type/constants.mjs";
 import { env } from "../universal/env.mjs";
 
 //#region src/compile/aot.ts
@@ -200,6 +201,53 @@ const EMPTY_EXTERNALS = Object.freeze([]);
 function instantiateFrozenBoth(frozen, checkSchema, mirrorSchema) {
 	return frozen.cm(frozen.e ? collectExternals(checkSchema) : EMPTY_EXTERNALS, frozen.u ? { unions: buildUnions(frozen.u, mirrorSchema) } : void 0);
 }
+function collectStringCodecNodes(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	const ely = schema["~elyTyp"];
+	if (ely === ELYSIA_TYPES.ObjectString || ely === ELYSIA_TYPES.ArrayString) {
+		const inner = schema.anyOf?.[0];
+		const codec = schema.anyOf?.[1];
+		if (inner && codec?.["~codec"] && codec["~refine"]) out.push({
+			inner,
+			codec,
+			open: ely === ELYSIA_TYPES.ObjectString ? 123 : 91
+		});
+	}
+	if (schema.properties) for (const k in schema.properties) collectStringCodecNodes(schema.properties[k], out);
+	const items = schema.items;
+	if (Array.isArray(items)) for (const it of items) collectStringCodecNodes(it, out);
+	else if (items) collectStringCodecNodes(items, out);
+	if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectStringCodecNodes(b, out);
+	return out;
+}
+/**
+* Overwrite every ObjectString/ArrayString node's `~refine[0].check` and
+* `~codec.decode` with the baked `ic` closures. After this runs, the node no
+* longer calls the constructor's live `typebox/value` Check/Decode
+*
+* Iterate in reverse so nested codecs reconstruct bottom-up.
+*/
+function reconstructInnerCodecs(ic, schema) {
+	const nodes = collectStringCodecNodes(schema);
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const entry = ic[i];
+		const node = nodes[i];
+		if (!entry || !node) continue;
+		const innerSchema = node.inner;
+		const innerCheck = entry.c(entry.e ? collectExternals(innerSchema) : []);
+		const innerMirror = entry.d.x ? instantiateFrozenDecodeMirror(entry.d, innerSchema) : entry.d.s;
+		const open = entry.o;
+		node.codec["~refine"][0].check = (v) => {
+			if (v.charCodeAt(0) !== open) return false;
+			try {
+				return innerCheck(JSON.parse(v));
+			} catch {
+				return false;
+			}
+		};
+		node.codec["~codec"].decode = (v) => innerMirror(JSON.parse(v));
+	}
+}
 /**
 * verify that mirror unions can be reconstructed in build time
 *
@@ -292,4 +340,4 @@ const Capture = {
 const resetCaptureLifecycleForTests = () => void 0;
 
 //#endregion
-export { Capture, Compiled, EMPTY_EXTERNALS, Source, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, resetCaptureLifecycleForTests };
+export { Capture, Compiled, EMPTY_EXTERNALS, Source, beginValidatorCapture, collectExternals, collectMirrorUnions, collectStringCodecNodes, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, reconstructInnerCodecs, resetCaptureLifecycleForTests };

package/dist/compile/handler/frozen-validator.d.ts

@@ -1,5 +1,5 @@
-import { AnyLocalHook, HTTPMethod } from "../../types.js";
 import { CapturedValidator, FrozenValidator } from "../aot.js";
+import { AnyLocalHook, HTTPMethod } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/frozen-validator.d.ts
@@ -8,7 +8,7 @@ declare class FrozenSlotValidator {
   #private;
   isAsync: boolean;
   schema: unknown;
-  constructor(frozen: FrozenValidator, schema: unknown, normalize: boolean | 'exactMirror' | 'typebox' | undefined);
+  constructor(frozen: FrozenValidator, schema: unknown, raw: unknown, normalize: boolean | 'exactMirror' | 'typebox' | undefined);
   Check(value: unknown): boolean;
   Errors(): unknown[];
   From(value: unknown, type?: string): unknown;
@@ -22,19 +22,9 @@ interface FrozenRouteValidatorShape {
   cookie?: FrozenSlotValidator;
   response?: Record<number, FrozenSlotValidator>;
 }
-/**
- * Attempt to build an entire route validator bridge-free.
- *
- * Returns `undefined` (caller falls back to the wired `RouteValidator`) unless
- * EVERY declared slot — request and response — is bridge-free-complete. All or
- * nothing per route: a partial mix would still drag the bridge for one slot,
- * defeating the point, and the handler factory expects one uniform validator.
- */
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
 /**
- * Build-time twin of `isBridgeFreeComplete`, operating on the captured entry +
- * its schema. The build plugin can aggregate this across every slot to decide
- * whether a manifest is "fully bridge-free"
+ * Build-time twin of `isBridgeFreeComplete`, operating on the captured entry & its schema
  */
 declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown): boolean;
 //#endregion