elysia 2.0.0-exp.28 → 2.0.0-exp.29

package/dist/base.js

@@ -834,7 +834,7 @@ 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);
@@ -944,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;
@@ -954,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();
@@ -1000,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];
@@ -1040,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

@@ -831,7 +831,7 @@ 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);
@@ -941,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;
@@ -951,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();
@@ -997,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];
@@ -1037,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

@@ -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

package/dist/compile/handler/frozen-validator.js

@@ -3,15 +3,24 @@ const require_utils = require('../../utils.js');
 const require_type_constants = require('../../type/constants.js');
 const require_error = require('../../error.js');
 const require_compile_aot = require('../aot.js');
+const require_type_coerce_plan = require('../../type/coerce-plan.js');
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
-function codecCoercionBridgeFree(f) {
-	return f.k === 1 && !!f.dm && !f.cp && !f.ic && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1);
+function codecCoercionBridgeFree(f, coerced, raw) {
+	return f.k === 1 && !!f.dm && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1) && innerCodecsAligned(f.ic?.length, coerced) && mirrorUnionsAligned(f.u, raw) && mirrorUnionsAligned(f.dm.u, coerced);
 }
-function isBridgeFreeComplete(f, schema) {
+const innerCodecsAligned = (icLength, coerced) => require_compile_aot.collectStringCodecNodes(coerced).length === (icLength ?? 0);
+function mirrorUnionsAligned(u, schema) {
+	if (!u) return true;
+	const branches = require_compile_aot.collectMirrorUnions(schema);
+	if (branches.length !== u.length) return false;
+	for (let ui = 0; ui < u.length; ui++) if (branches[ui].length !== u[ui].length) return false;
+	return true;
+}
+function isBridgeFreeComplete(f, schema, raw) {
 	if (!f.cm) return false;
-	if (codecCoercionBridgeFree(f)) return true;
+	if (codecCoercionBridgeFree(f, schema, raw)) return true;
 	if (f.e === 1 || f.u || f.dm || f.em || f.k === 1 || f.ce || f.ic || f.a === 1) return false;
 	if (f.d === 1 && f.ps !== 1) return false;
 	if (isFullyClosedObject(schema)) return false;
@@ -58,11 +67,12 @@ var FrozenSlotValidator = class {
 	#defaultFastPath;
 	#hasOptional;
 	#noValidate;
-	constructor(frozen, schema, normalize) {
+	constructor(frozen, schema, raw, normalize) {
 		this.isAsync = false;
 		this.schema = schema;
+		if (frozen.ic) require_compile_aot.reconstructInnerCodecs(frozen.ic, schema);
 		if (frozen.k === 1 && frozen.dm) {
-			const both = require_compile_aot.instantiateFrozenBoth(frozen, schema, schema);
+			const both = require_compile_aot.instantiateFrozenBoth(frozen, schema, raw);
 			this.#check = both.check;
 			this.#clean = normalize === false ? void 0 : both.clean;
 			this.#decode = normalize === false ? void 0 : require_compile_aot.instantiateFrozenDecodeMirror(frozen.dm, schema);
@@ -132,36 +142,11 @@ const REQUEST_SLOTS = [
 	"params",
 	"cookie"
 ];
-/**
-* Resolve a slot schema to the concrete TypeBox schema the wired path validates.
-*
-* A slot can be a STRING model reference (`.post(path, { body: 'myModel' })`);
-* the wired path resolves it via `Validator.reference(schema, models)` before
-* building anything, so its closed-object / coverage checks and Clean see the
-* resolved object. The bridge-free path receives the RAW hook schema (the bare
-* string), so it must resolve the same way BEFORE any check — otherwise a closed
-* model ref (`type` is a string, not an object) dodges `isFullyClosedObject` and
-* builds bridge-free, diverging from the wired `#cleanRedundant` Clean-skip.
-*
-* Mirrors `Validator.reference` semantics without importing it (that module
-* statically pulls the TypeBox bridge this module must stay free of): non-string
-* passes through; a string that names a registered model resolves; a string that
-* names nothing returns `undefined` so the caller bails and the wired path
-* surfaces the "not found" error loudly instead of silently diverging.
-*/
 function resolveModelRef(schema, root) {
 	if (typeof schema !== "string") return schema;
 	const models = root["~ext"]?.models;
 	if (models && schema in models) return models[schema];
 }
-/**
-* 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.
-*/
 function buildFrozenRouteValidator(hook, root, method, path) {
 	if (root["~config"]?.normalize === "typebox") return void 0;
 	if (hook?.schemas) return void 0;
@@ -173,8 +158,10 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		const schema = resolveModelRef(raw, root);
 		if (!schema) return void 0;
 		const frozen = require_compile_aot.Compiled.getValidator(method, path, slot);
-		if (!frozen || !isBridgeFreeComplete(frozen, schema)) return void 0;
-		out[slot] = new FrozenSlotValidator(frozen, schema, normalize);
+		if (!frozen) return void 0;
+		const coerced = frozen.cp ? require_type_coerce_plan.buildCoercedFromPlan(schema, frozen.cp) : schema;
+		if (!isBridgeFreeComplete(frozen, coerced, schema)) return void 0;
+		out[slot] = new FrozenSlotValidator(frozen, coerced, schema, normalize);
 	}
 	const response = hook?.response;
 	if (response) {
@@ -186,8 +173,8 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			const schema = resolveModelRef(raw, root);
 			if (!schema) return void 0;
 			const frozen = require_compile_aot.Compiled.getValidator(method, path, `response:${status}`);
-			if (!frozen || !isBridgeFreeComplete(frozen, schema)) return void 0;
-			responseOut[status] = new FrozenSlotValidator(frozen, schema, normalize);
+			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
+			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
 		}
 		out.response = responseOut;
 	}
@@ -195,9 +182,7 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 }
 const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
 /**
-* 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
 */
 function isCapturedBridgeFree(c, schema) {
 	if (typeof schema === "string") return false;
@@ -208,7 +193,10 @@ function isCapturedBridgeFree(c, schema) {
 	* @see plugin/source.ts `entryParts`
 	*/
 	if (!(c.checkValue && c.mirror)) return false;
-	if (c.hasCodec && !!c.decodeMirror && !c.coercePlan && !c.innerCodecs?.length && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) return true;
+	if (c.hasCodec && !!c.decodeMirror && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) {
+		const coerced = c.coercePlan ? require_type_coerce_plan.buildCoercedFromPlan(schema, c.coercePlan) : schema;
+		return innerCodecsAligned(c.innerCodecs?.length, coerced) && mirrorUnionsAligned(c.mirror.u, schema) && mirrorUnionsAligned(c.decodeMirror.u, coerced);
+	}
 	if (c.external || c.mirror.u || c.decodeMirror || c.encodeMirror || c.hasCodec || c.customErrors?.length || c.innerCodecs?.length || c.async) return false;
 	if (c.hasDefault && !c.precomputeSafe) return false;
 	if (isFullyClosedObject(schema)) return false;