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

package/dist/compile/handler/descriptor.mjs

@@ -1,11 +1,11 @@
 import { isNotEmpty } from "../../utils.mjs";
+import { hasSyncHmac } from "../../cookie/crypto.mjs";
 import { Capture } from "../aot.mjs";
 import { frozenRootOf, resolvedTraceOf, traceCapabilityRequired } from "../../generation.mjs";
-import { hasSyncHmac } from "../../cookie/crypto.mjs";
-import { compileCookieConfig } from "../../cookie/config.mjs";
 import { isAsyncFunction, isAsyncLifecycle, mayReturnPromise } from "../utils.mjs";
 import { JITProbe } from "../jit-probe.mjs";
 import { mergeInference, sucrose } from "../../sucrose.mjs";
+import { Reconstrct } from "./reconstruct.mjs";
 
 //#region src/compile/handler/descriptor.ts
 /**
@@ -14,16 +14,7 @@ import { mergeInference, sucrose } from "../../sucrose.mjs";
 */
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
 const noTracePhases = /* @__PURE__ */ new Set();
-const matchReturnIdentifier = /(?:=>\s*|\breturn\s+)(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifierCache = /* @__PURE__ */ new WeakMap();
-function mayReturnIdentifier(fn) {
-	let result = mayReturnIdentifierCache.get(fn);
-	if (result !== void 0) return result;
-	result = matchReturnIdentifier.test(fn.toString());
-	mayReturnIdentifierCache.set(fn, result);
-	return result;
-}
-const lifecycleMayReturnPromise = (handlers, observed) => handlers ? Array.isArray(handlers) ? handlers.some((fn) => !isAsyncFunction(fn) && (mayReturnPromise(fn) || observed && mayReturnIdentifier(fn))) : !isAsyncFunction(handlers) && (mayReturnPromise(handlers) || observed && mayReturnIdentifier(handlers)) : false;
+const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(mayReturnPromise) : mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
 const compactPrefixAsync = /* @__PURE__ */ new WeakMap();
 const inferCompactPrefix = (prefix) => {
@@ -65,27 +56,13 @@ function compactPrefixForcesAsync(prefix) {
 		const item = pending[i];
 		for (let j = 0; !value && j < item.added.length; j++) {
 			const fn = item.added[j];
-			value = isAsyncFunction(fn) || !isAsyncFunction(fn) && (mayReturnPromise(fn) || mayReturnIdentifier(fn));
+			value = mayReturnPromise(fn);
 		}
 		compactPrefixAsync.set(item, value);
 	}
 	return value;
 }
-const isAsyncValidator = (vali) => vali?.isAsync ?? true;
-const mayReturnPromiseValidator = (vali) => vali?.mayReturnPromise === true;
-/**
-* Extracted from `buildNativeStaticResponse`'s for-in check so the native
-* static promotion predicate
-*/
-function isEmptyPipelineHook(hook) {
-	if (!hook) return true;
-	for (const key in hook) {
-		if (key === "detail" || key === "tags") continue;
-		const value = hook[key];
-		if (value !== void 0 && value !== false && (!Array.isArray(value) || value.length)) return false;
-	}
-	return true;
-}
+const isAsyncValidator = (vali) => (vali?.isAsync ?? true) || vali?.mayReturnPromise === true;
 function describeRoute(input) {
 	const { method, handler, root, adapter, hook, buildValidator, isHandleFunction, isStaticResponse, isPromiseHandler } = input;
 	const vali = buildValidator();
@@ -99,14 +76,13 @@ function describeRoute(input) {
 	const hasMergeBody = !!hook?.schemas?.some((s) => s?.body);
 	const bodylessMethod = method === "GET" || method === "HEAD";
 	const hasBody = !!hook?.body || hasMergeBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
-	const bodyValiIsAsync = hasBody && (isAsyncValidator(vali?.body) || mayReturnPromiseValidator(vali?.body));
-	const headersValiIsAsync = vali?.headers && (isAsyncValidator(vali?.headers) || mayReturnPromiseValidator(vali?.headers));
-	const paramsValiIsAsync = vali?.params && (isAsyncValidator(vali?.params) || mayReturnPromiseValidator(vali?.params));
-	const queryValiIsAsync = vali?.query && (isAsyncValidator(vali?.query) || mayReturnPromiseValidator(vali?.query));
-	const cookieValidIsAsync = vali?.cookie && (isAsyncValidator(vali?.cookie) || mayReturnPromiseValidator(vali?.cookie));
-	const appCookieConfig = frozenRootOf(root)["~config"]?.cookie;
+	const bodyValiIsAsync = hasBody && isAsyncValidator(vali?.body);
+	const headersValiIsAsync = vali?.headers && isAsyncValidator(vali.headers);
+	const paramsValiIsAsync = vali?.params && isAsyncValidator(vali.params);
+	const queryValiIsAsync = vali?.query && isAsyncValidator(vali.query);
+	const cookieValidIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
 	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? compileCookieConfig(hook?.cookie, appCookieConfig) : void 0;
+	const cookieConfig = needsCookie ? Reconstrct.cookie(hook, root) : void 0;
 	const hasCookieSign = !!cookieConfig?.hasSign;
 	const syncCookieSign = hasCookieSign && hasSyncHmac && !Capture.isCapturing();
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
@@ -130,19 +106,20 @@ function describeRoute(input) {
 	const traceHandleOn = phaseOn("handle");
 	let responseValiAsync = false;
 	if (vali?.response) {
-		for (const code in vali.response) if (isAsyncValidator(vali.response[code]) || mayReturnPromiseValidator(vali.response[code])) {
+		for (const code in vali.response) if (isAsyncValidator(vali.response[code])) {
 			responseValiAsync = true;
 			break;
 		}
 	}
 	const handlerIsAsync = isHandleFunction && isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
+	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));
-	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || hook && (!!isAsyncLifecycle(hook?.afterHandle) || !!isAsyncLifecycle(hook?.beforeHandle) || !!isAsyncLifecycle(hook?.transform) || !!isAsyncLifecycle(hook?.mapResponse) || !!isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
+	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && mayReturnPromise(handler);
+	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && mayReturnPromise(handler);
+	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
+	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync;
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
+	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValidIsAsync && !(hook && (isAsyncLifecycle(hook.afterHandle) || isAsyncLifecycle(hook.beforeHandle) || isAsyncLifecycle(hook.transform) || isAsyncLifecycle(hook.mapResponse) || isAsyncLifecycle(hook.error)));
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
 	const handlerKind = isHandleFunction ? "function" : isStaticResponse ? "response" : isPromiseHandler ? "promise" : "static-value";
@@ -153,6 +130,7 @@ function describeRoute(input) {
 		descriptor: {
 			handlerKind,
 			async: !!isAsync,
+			tail,
 			responseMode,
 			hasBeforeHandle,
 			hasAfterHandle,
@@ -191,4 +169,4 @@ function describeRoute(input) {
 }
 
 //#endregion
-export { describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, mayReturnIdentifier, routeDescriptors };
+export { describeRoute, routeDescriptors };

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

@@ -4,21 +4,13 @@ import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/frozen-validator.d.ts
 declare const isBridgeNotInitialized: (error: unknown) => boolean;
-/** `{ check, clean?, decode? }` the slot's compiled predicate + cleaner. */
-interface SlotCheckClean {
-  check: (value: unknown) => boolean;
-  clean?: (value: unknown) => unknown;
-  decode?: (value: unknown) => unknown;
-}
-declare function isCompactDiagnosable(schema: any): boolean;
-declare function isCompactWalkable(schema: any): boolean;
+declare function isCompactWalkable(schema: any, lookThrough?: boolean): boolean;
 declare class FrozenSlotValidator {
   #private;
   isAsync: boolean;
   hasCodec: boolean;
   schema: unknown;
   constructor(frozen: FrozenValidator, schema: unknown, raw: unknown, normalize: boolean | 'exactMirror' | 'typebox' | undefined);
-  protected buildCheckClean(frozen: FrozenValidator, schema: unknown, raw: unknown, normalize: boolean | 'exactMirror' | 'typebox' | undefined): SlotCheckClean;
   Check(value: unknown): boolean;
   Errors(value: unknown): unknown[];
   From(value: unknown, type?: string): unknown;
@@ -32,9 +24,12 @@ interface FrozenRouteValidatorShape {
   cookie?: FrozenSlotValidator;
   response?: Record<number, FrozenSlotValidator>;
 }
+declare const REQUEST_SLOTS: readonly ["body", "headers", "query", "params", "cookie"];
 declare const isStandardSchema: (schema: unknown) => schema is object & Record<"~standard", unknown>;
 declare function mergeSchemasAllStandard(schemas: Array<Record<string, unknown>> | undefined): boolean;
+declare function resolveModelRef(schema: unknown, root: AnyElysia): unknown;
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
+declare const isResponseMap: (schema: unknown) => schema is Record<string, unknown>;
 declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown, coerced?: unknown): boolean;
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };
+export { REQUEST_SLOTS, buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactWalkable, isResponseMap, isStandardSchema, mergeSchemasAllStandard, resolveModelRef };

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

@@ -9,10 +9,6 @@ const require_validator_index = require('../../validator/index.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, 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);
-}
-const innerCodecsAligned = (icLength, coerced) => require_compile_aot.reconstruct().collectStringCodecNodes(coerced).length === (icLength ?? 0);
 function mirrorUnionsAligned(u, schema) {
 	if (!u) return true;
 	const branches = require_compile_aot.reconstruct().collectMirrorUnions(schema);
@@ -22,25 +18,12 @@ function mirrorUnionsAligned(u, schema) {
 }
 function isBridgeFreeComplete(f, schema, raw) {
 	if (!f.cm) return false;
-	if (codecCoercionBridgeFree(f, schema, raw)) return true;
+	if (f.k === 1 && !!f.dm && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1) && (f.ic?.length ?? 0) === require_compile_aot.reconstruct().collectStringCodecNodes(schema).length && mirrorUnionsAligned(f.u, raw) && mirrorUnionsAligned(f.dm.u, schema)) 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 (require_type_validator_clean_safe.isFullyClosedObject(schema)) return false;
 	return true;
 }
-const EMPTY_EXTERNALS = Object.freeze([]);
-function jsTypeMatches(value, type) {
-	switch (type) {
-		case "string": return typeof value === "string";
-		case "number": return typeof value === "number";
-		case "integer": return typeof value === "number" && Number.isInteger(value);
-		case "boolean": return typeof value === "boolean";
-		case "null": return value === null;
-		case "array": return Array.isArray(value);
-		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
-		default: return true;
-	}
-}
 const typeError = (schema, instancePath, schemaPath) => ({
 	keyword: "type",
 	schemaPath,
@@ -98,63 +81,28 @@ function walkCompactError(schema, value, instancePath, schemaPath) {
 		}
 		return;
 	}
-	if (typeof type === "string" && !jsTypeMatches(value, type)) return typeError(schema, instancePath, schemaPath);
-}
-function bestEffortCodecError(schema, value) {
-	if (schema?.type === "object" && typeof value === "object" && value !== null && !Array.isArray(value) && schema.properties) for (const key in schema.properties) {
-		if (!(key in value)) continue;
-		if (isCompactDiagnosable(schema.properties[key])) continue;
-		return {
-			keyword: "type",
-			schemaPath: `#/properties/${key}`,
-			instancePath: `/${key}`,
-			params: {},
-			message: `must match ${schema.properties[key]?.["~kind"] ?? "schema"}`
-		};
-	}
-	return {
-		keyword: "type",
-		schemaPath: "#",
-		instancePath: "",
-		params: {},
-		message: `must match ${schema?.["~kind"] ?? "schema"}`
-	};
-}
-function isCompactDiagnosable(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
-	const type = schema.type;
-	if (type === "object") {
-		const properties = schema.properties;
-		if (properties) {
-			for (const key in properties) if (!isCompactDiagnosable(properties[key])) return false;
-		}
-		return true;
-	}
-	if (type === "array") return isCompactDiagnosable(schema.items);
-	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+	if (!(type === "string" || type === "number" || type === "boolean" ? typeof value === type : type === "integer" ? Number.isInteger(value) : type !== "null" || value === null)) return typeError(schema, instancePath, schemaPath);
 }
-function isCompactWalkable(schema) {
+function isCompactWalkable(schema, lookThrough = true) {
 	if (!schema || typeof schema !== "object") return false;
 	const elyTyp = schema["~elyTyp"];
-	if (schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
+	if (lookThrough && schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
 	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
 	const type = schema.type;
 	if (type === "object") {
 		const properties = schema.properties;
 		if (properties) {
-			for (const key in properties) if (!isCompactWalkable(properties[key])) return false;
+			for (const key in properties) if (!isCompactWalkable(properties[key], lookThrough)) return false;
 		}
 		return true;
 	}
-	if (type === "array") return isCompactWalkable(schema.items);
+	if (type === "array") return isCompactWalkable(schema.items, lookThrough);
 	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
 }
 var FrozenSlotValidator = class {
 	#check;
 	#clean;
 	#decode;
-	#hasDefault;
 	#defaultFastPath;
 	#hasOptional;
 	#noValidate;
@@ -163,13 +111,21 @@ var FrozenSlotValidator = class {
 		this.hasCodec = false;
 		this.schema = schema;
 		this.hasCodec = frozen.k === 1;
-		const built = this.buildCheckClean(frozen, schema, raw, normalize);
-		this.#check = built.check;
-		this.#clean = built.clean;
-		this.#decode = built.decode;
+		if (frozen.ic) require_compile_aot.reconstruct().reconstructInnerCodecs(frozen.ic, schema);
+		if (frozen.k === 1 && frozen.dm) {
+			const both = require_compile_aot.reconstruct().instantiateFrozenBoth(frozen, schema, raw);
+			this.#check = both.check;
+			if (normalize !== false) {
+				this.#clean = both.clean;
+				this.#decode = require_compile_aot.reconstruct().instantiateFrozenDecodeMirror(frozen.dm, schema);
+			}
+		} else {
+			const both = frozen.cm(require_compile_aot.EMPTY_EXTERNALS, void 0);
+			this.#check = both.check;
+			if (normalize !== false) this.#clean = both.clean;
+		}
 		this.#hasOptional = !!schema?.["~optional"];
 		this.#noValidate = schema?.["~elyTyp"] === require_type_constants.ELYSIA_TYPES.NoValidate;
-		this.#hasDefault = frozen.d === 1;
 		if (frozen.ps === 1) this.#defaultFastPath = {
 			value: frozen.pd,
 			appliesToNull: frozen.pn === 1,
@@ -177,20 +133,34 @@ var FrozenSlotValidator = class {
 			merge: frozen.pm
 		};
 	}
-	buildCheckClean(frozen, schema, raw, normalize) {
-		const both = frozen.cm(EMPTY_EXTERNALS, void 0);
-		return {
-			check: both.check,
-			clean: normalize === false ? void 0 : both.clean
-		};
-	}
 	Check(value) {
 		return this.#check(value);
 	}
 	Errors(value) {
 		const hit = walkCompactError(this.schema, value, "", "#");
 		if (hit) return [hit];
-		return [bestEffortCodecError(this.schema, value)];
+		const schema = this.schema;
+		let error;
+		if (schema?.type === "object" && typeof value === "object" && value !== null && !Array.isArray(value) && schema.properties) for (const key in schema.properties) {
+			if (!(key in value)) continue;
+			if (isCompactWalkable(schema.properties[key], false)) continue;
+			error = {
+				keyword: "type",
+				schemaPath: `#/properties/${key}`,
+				instancePath: `/${key}`,
+				params: {},
+				message: `must match ${schema.properties[key]?.["~kind"] ?? "schema"}`
+			};
+			break;
+		}
+		if (!error) error = {
+			keyword: "type",
+			schemaPath: "#",
+			instancePath: "",
+			params: {},
+			message: `must match ${schema?.["~kind"] ?? "schema"}`
+		};
+		return [error];
 	}
 	#error(value, type) {
 		return new require_error.ValidationError(type, value, () => this.Errors(value), this.schema);
@@ -201,16 +171,11 @@ var FrozenSlotValidator = class {
 		if (value === null || typeof value !== "object") return value;
 		return defaults.clone ? defaults.clone() : structuredClone(value);
 	}
-	#applyDefault(value) {
-		return this.#defaultFastPath.merge(value);
-	}
 	From(value, type) {
-		if (this.#hasDefault) {
-			const defaults = this.#defaultFastPath;
-			if (defaults) {
-				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
-				else if (value !== null && typeof value === "object" && defaults.merge !== void 0) value = this.#applyDefault(value);
-			}
+		const defaults = this.#defaultFastPath;
+		if (defaults) {
+			if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+			else if (value !== null && typeof value === "object" && defaults.merge !== void 0) value = defaults.merge(value);
 		}
 		if (this.#hasOptional) {
 			const schema = this.schema;
@@ -226,25 +191,6 @@ var FrozenSlotValidator = class {
 		return this.#clean ? this.#clean(value) : value;
 	}
 };
-/**
-* The JIT/frozen slot validator: the reconstruct-free `FrozenSlotValidator`
-* base plus the codec/inner-codec branch re-added via the `buildCheckClean`
-* override
-*/
-var CodecFrozenSlotValidator = class extends FrozenSlotValidator {
-	buildCheckClean(frozen, schema, raw, normalize) {
-		if (frozen.ic) require_compile_aot.reconstruct().reconstructInnerCodecs(frozen.ic, schema);
-		if (frozen.k === 1 && frozen.dm) {
-			const both = require_compile_aot.reconstruct().instantiateFrozenBoth(frozen, schema, raw);
-			return {
-				check: both.check,
-				clean: normalize === false ? void 0 : both.clean,
-				decode: normalize === false ? void 0 : require_compile_aot.reconstruct().instantiateFrozenDecodeMirror(frozen.dm, schema)
-			};
-		}
-		return super.buildCheckClean(frozen, schema, raw, normalize);
-	}
-};
 const REQUEST_SLOTS = [
 	"body",
 	"headers",
@@ -290,11 +236,13 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			coerced = rebuild(schema, frozen.cp);
 		}
 		if (!isBridgeFreeComplete(frozen, coerced, schema)) return void 0;
-		out[slot] = new CodecFrozenSlotValidator(frozen, coerced, schema, normalize);
+		out[slot] = new FrozenSlotValidator(frozen, coerced, schema, normalize);
 	}
 	const response = hook?.response;
 	if (response) {
-		const statuses = isResponseMap(response) ? response : { 200: response };
+		const resolved = resolveModelRef(response, root);
+		if (!resolved) return void 0;
+		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
 		const responseOut = {};
 		for (const status in statuses) {
 			const raw = statuses[status];
@@ -307,13 +255,13 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			}
 			const frozen = require_compile_aot.Compiled.getValidator(method, path, `response:${status}`, root["~programId"]);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
-			responseOut[status] = new CodecFrozenSlotValidator(frozen, schema, schema, normalize);
+			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
 		}
 		out.response = responseOut;
 	}
 	return out;
 }
-const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
+const isResponseMap = (schema) => schema !== null && typeof schema === "object" && !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
 const capturedBothMarker = (() => ({}));
 function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
@@ -340,10 +288,12 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
+exports.REQUEST_SLOTS = REQUEST_SLOTS;
 exports.buildFrozenRouteValidator = buildFrozenRouteValidator;
 exports.isBridgeNotInitialized = isBridgeNotInitialized;
 exports.isCapturedBridgeFree = isCapturedBridgeFree;
-exports.isCompactDiagnosable = isCompactDiagnosable;
 exports.isCompactWalkable = isCompactWalkable;
+exports.isResponseMap = isResponseMap;
 exports.isStandardSchema = isStandardSchema;
-exports.mergeSchemasAllStandard = mergeSchemasAllStandard;
+exports.mergeSchemasAllStandard = mergeSchemasAllStandard;
+exports.resolveModelRef = resolveModelRef;