elysia 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/compile/aot.d.ts

@@ -1,6 +1,6 @@
 import { CoerceNode } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
-declare const AOT_MANIFEST_FORMAT = 5;
+declare const AOT_MANIFEST_FORMAT = 6;
 interface AotFingerprint {
   abi: string;
 }
@@ -79,8 +79,9 @@ interface ValidatorManifest {
   };
 }
 interface FrozenHandler {
-  a: string[];
-  f: (...deps: unknown[]) => unknown;
+  a?: string[];
+  f?: (...deps: unknown[]) => unknown;
+  k?: number;
 }
 interface HandlerManifest {
   [method: string]: {
@@ -125,6 +126,8 @@ interface ReconstructImpl {
   reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
 }
 declare function reconstruct(): ReconstructImpl;
+declare const aotDrift: (method: string, path: string) => string;
+declare function warnAotDrift(method: string, path: string): void;
 declare abstract class Compiled {
   static register(manifest: CompiledProgramRegistration): void;
   static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
@@ -135,10 +138,6 @@ declare abstract class Compiled {
   static getValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): boolean;
   static getPlanRebuilder(id?: ProgramId): ((original: unknown, plan: CoerceNode) => any) | undefined;
-  /**
-   * Drop a fully consumed program registration after an eager production
-   * build publishes. Safe only when every route compiled before publish
-   */
   static release(id: ProgramId): void;
   /** @internal test isolation */
   static clear(): void;
@@ -221,6 +220,7 @@ interface CapturedHandler {
   path: string;
   alias: string;
   code: string;
+  k: number | undefined;
 }
 declare function captureHandler(v: CapturedHandler): void;
 declare function captureSet(loc: {
@@ -282,4 +282,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

package/dist/compile/aot.js

@@ -4,8 +4,8 @@ const require_universal_env = require('../universal/env.js');
 const require_package = require('../package.js');
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 5;
-const AOT_ABI = `${require_package.version}:${5}`;
+const AOT_MANIFEST_FORMAT = 6;
+const AOT_ABI = `${require_package.version}:${6}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
@@ -37,12 +37,16 @@ function reconstruct() {
 	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
+let drifted;
+const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+function warnAotDrift(method, path) {
+	const key = method + " " + path;
+	if (drifted?.has(key)) return;
+	drifted ??= /* @__PURE__ */ new Set();
+	drifted.add(key);
+	console.warn(aotDrift(method, path) + ", compiled at runtime");
+}
 let registered;
-/**
-* App that consumed this process's manifest, held weakly: it only has to
-* recognise a re-claim by the *same* app, and `assertUncontested` always
-* compares against a live id, so a cleared ref answers as a strong one would
-*/
 let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
@@ -54,8 +58,7 @@ var Compiled = class {
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
-		const expected = manifest.fingerprint;
-		if (expected.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: abi (manifest ${expected.abi}, app ${fingerprint.abi}).`);
+		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
 		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
@@ -105,10 +108,6 @@ var Compiled = class {
 	static getPlanRebuilder(id) {
 		return programFor(id)?.planRebuilder;
 	}
-	/**
-	* Drop a fully consumed program registration after an eager production
-	* build publishes. Safe only when every route compiled before publish
-	*/
 	static release(id) {
 		programs.delete(id);
 	}
@@ -117,6 +116,7 @@ var Compiled = class {
 		registered = void 0;
 		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
+		drifted?.clear();
 	}
 };
 /**
@@ -194,6 +194,7 @@ exports.Compiled = Compiled;
 exports.CompilerState = CompilerState;
 exports.EMPTY_EXTERNALS = EMPTY_EXTERNALS;
 exports.aotActivationError = aotActivationError;
+exports.aotDrift = aotDrift;
 exports.beginCompilerSession = beginCompilerSession;
 Object.defineProperty(exports, 'captureImpl', {
   enumerable: true,
@@ -205,4 +206,5 @@ exports.createAotFingerprint = createAotFingerprint;
 exports.endCompilerSession = endCompilerSession;
 exports.getCompilerSession = getCompilerSession;
 exports.reconstruct = reconstruct;
-exports.setCaptureImpl = setCaptureImpl;
+exports.setCaptureImpl = setCaptureImpl;
+exports.warnAotDrift = warnAotDrift;

package/dist/compile/aot.mjs

@@ -3,8 +3,8 @@ import { env } from "../universal/env.mjs";
 import { version } from "../package.mjs";
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 5;
-const AOT_ABI = `${version}:${5}`;
+const AOT_MANIFEST_FORMAT = 6;
+const AOT_ABI = `${version}:${6}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
@@ -36,12 +36,16 @@ function reconstruct() {
 	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
+let drifted;
+const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+function warnAotDrift(method, path) {
+	const key = method + " " + path;
+	if (drifted?.has(key)) return;
+	drifted ??= /* @__PURE__ */ new Set();
+	drifted.add(key);
+	console.warn(aotDrift(method, path) + ", compiled at runtime");
+}
 let registered;
-/**
-* App that consumed this process's manifest, held weakly: it only has to
-* recognise a re-claim by the *same* app, and `assertUncontested` always
-* compares against a live id, so a cleared ref answers as a strong one would
-*/
 let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
@@ -53,8 +57,7 @@ var Compiled = class {
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
-		const expected = manifest.fingerprint;
-		if (expected.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: abi (manifest ${expected.abi}, app ${fingerprint.abi}).`);
+		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
 		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
@@ -104,10 +107,6 @@ var Compiled = class {
 	static getPlanRebuilder(id) {
 		return programFor(id)?.planRebuilder;
 	}
-	/**
-	* Drop a fully consumed program registration after an eager production
-	* build publishes. Safe only when every route compiled before publish
-	*/
 	static release(id) {
 		programs.delete(id);
 	}
@@ -116,6 +115,7 @@ var Compiled = class {
 		registered = void 0;
 		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
+		drifted?.clear();
 	}
 };
 /**
@@ -187,4 +187,4 @@ function setCaptureImpl(impl) {
 }
 
 //#endregion
-export { AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

package/dist/compile/handler/descriptor.js

@@ -3,10 +3,10 @@ const require_utils = require('../../utils.js');
 const require_cookie_crypto = require('../../cookie/crypto.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
-const require_cookie_config = require('../../cookie/config.js');
 const require_compile_utils = require('../utils.js');
 const require_compile_jit_probe = require('../jit-probe.js');
 const require_sucrose = require('../../sucrose.js');
+const require_compile_handler_reconstruct = require('./reconstruct.js');
 
 //#region src/compile/handler/descriptor.ts
 /**
@@ -82,9 +82,8 @@ function describeRoute(input) {
 	const paramsValiIsAsync = vali?.params && isAsyncValidator(vali.params);
 	const queryValiIsAsync = vali?.query && isAsyncValidator(vali.query);
 	const cookieValidIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
-	const appCookieConfig = require_generation.frozenRootOf(root)["~config"]?.cookie;
 	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? require_cookie_config.compileCookieConfig(hook?.cookie, appCookieConfig) : void 0;
+	const cookieConfig = needsCookie ? require_compile_handler_reconstruct.Reconstrct.cookie(hook, root) : void 0;
 	const hasCookieSign = !!cookieConfig?.hasSign;
 	const syncCookieSign = hasCookieSign && require_cookie_crypto.hasSyncHmac && !require_compile_aot.Capture.isCapturing();
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;

package/dist/compile/handler/descriptor.mjs

@@ -2,10 +2,10 @@ import { isNotEmpty } from "../../utils.mjs";
 import { hasSyncHmac } from "../../cookie/crypto.mjs";
 import { Capture } from "../aot.mjs";
 import { frozenRootOf, resolvedTraceOf, traceCapabilityRequired } from "../../generation.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
 /**
@@ -81,9 +81,8 @@ function describeRoute(input) {
 	const paramsValiIsAsync = vali?.params && isAsyncValidator(vali.params);
 	const queryValiIsAsync = vali?.query && isAsyncValidator(vali.query);
 	const cookieValidIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
-	const appCookieConfig = frozenRootOf(root)["~config"]?.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;

package/dist/compile/handler/index.d.ts

@@ -15,6 +15,7 @@ declare function chainResolver(root: AnyElysia): ((node: ChainNode) => Partial<A
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
 declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
 declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia, allowCompactPrefix?: boolean): AnyLocalHook | undefined;
+declare function routeShape(hook: AnyLocalHook | undefined, handler: unknown, root: AnyElysia): number | undefined;
 declare function compileHandler(route: InternalRoute, root: AnyElysia, liveOnly?: boolean): CompiledHandler;
 //#endregion
-export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, routeShape, setCaptureHeaderShorthand };

package/dist/compile/handler/index.js

@@ -6,11 +6,14 @@ const require_error = require('../../error.js');
 const require_adapter_web_standard_handler = require('../../adapter/web-standard/handler.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
+const require_compile_utils = require('../utils.js');
 const require_handler_utils = require('../../handler/utils.js');
+const require_compile_handler_utils = require('./utils.js');
 const require_compile_handler_params = require('./params.js');
 const require_compile_handler_jit = require('./jit.js');
-const require_compile_handler_descriptor = require('./descriptor.js');
+const require_compile_handler_frozen_validator = require('./frozen-validator.js');
 const require_compile_handler_reconstruct = require('./reconstruct.js');
+const require_compile_handler_descriptor = require('./descriptor.js');
 const require_adapter_constants = require('../../adapter/constants.js');
 
 //#region src/compile/handler/index.ts
@@ -274,18 +277,129 @@ function composeRouteHook(instance, localHook, appHook, inheritedChain, root, ma
 	}
 	return hook;
 }
-const hookStateAliases = [
-	"ho",
-	"tf",
-	"bf",
-	"af",
-	"mr",
-	"er",
-	"ar",
-	"va",
-	"cc",
-	"tr"
+const shapeEvents = [
+	"parse",
+	"transform",
+	"beforeHandle",
+	"afterHandle",
+	"mapResponse",
+	"afterResponse",
+	"error",
+	"trace"
+];
+const shapeSlots = [
+	"body",
+	"headers",
+	"params",
+	"query",
+	"cookie",
+	"response"
 ];
+const isCookieAt = (at) => at === "cookie" || at === "field";
+function childAt(at, k, value, deferred) {
+	if (at.endsWith("*")) return at.slice(0, -1);
+	if (at.endsWith("^")) return k === "0" ? at.slice(0, -1) + (Array.isArray(value) ? "*" : "") : "";
+	if (!isCookieAt(at)) return "";
+	switch (k) {
+		case "$ref": return at;
+		case "properties": return at === "cookie" ? "field*" : "";
+		case "parameters": return deferred ? at + "^" : "";
+	}
+	return k === "$defs" || require_utils.compositionKeys.includes(k) ? at + "*" : "";
+}
+function routeShape(hook, handler, root) {
+	const frozenRoot = require_generation.frozenRootOf(root);
+	const config = frozenRoot["~config"];
+	const models = frozenRoot["~ext"]?.models;
+	const refs = /* @__PURE__ */ new Map();
+	const addRef = (name, at = "") => {
+		if (!isCookieAt(at)) at = "";
+		if (at === "cookie" || !refs.get(name)) refs.set(name, at);
+	};
+	const ids = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	let unsupported = false;
+	for (const _ in []) return;
+	const shape = (v, at = "") => {
+		switch (typeof v) {
+			case "string": return JSON.stringify(v);
+			case "number": return "n" + (Object.is(v, -0) ? "-0" : v);
+			case "bigint": return "b" + v;
+			case "boolean": return v ? "T" : "F";
+			case "undefined": return "U";
+			case "function":
+				if (ids.has(v)) return "#" + ids.get(v);
+				ids.set(v, ids.size);
+				return require_compile_utils.isAsyncFunction(v) ? "fa" : "fs";
+			case "symbol":
+				unsupported = true;
+				return "";
+		}
+		if (v === null) return "N";
+		if ("~standard" in v) return "S";
+		if (visiting.has(v)) {
+			unsupported = true;
+			return "";
+		}
+		let tag = "";
+		const list = Array.isArray(v);
+		const proto = Object.getPrototypeOf(v);
+		if (list ? proto !== Array.prototype : proto !== null && proto !== Object.prototype) {
+			const kind = proto && Object.getOwnPropertyDescriptor(proto, "~kind");
+			if (!kind || !("value" in kind) || Reflect.ownKeys(proto).length !== 1 || Object.getPrototypeOf(proto) !== Object.prototype) {
+				unsupported = true;
+				return "";
+			}
+			tag = shape(kind.value);
+		}
+		visiting.add(v);
+		const map = at === "response" && require_compile_handler_frozen_validator.isResponseMap(v);
+		const deferred = v["~kind"] === "Deferred";
+		let s = (list ? "[" : "{") + tag;
+		for (const k of Reflect.ownKeys(v)) {
+			const d = Object.getOwnPropertyDescriptor(v, k);
+			if (typeof k === "symbol" || !("value" in d)) {
+				unsupported = true;
+				break;
+			}
+			const value = d.value;
+			if (k === "$ref" && typeof value === "string") addRef(value, at);
+			s += "," + (d.enumerable ? "" : "!") + JSON.stringify(k) + ":";
+			if (map) s += named(value);
+			else if (k === "config" && isCookieAt(at)) s += shape([value?.sign, !!value?.secrets]);
+			else if (k === "secrets" && (typeof value === "string" || Array.isArray(value))) s += shape(!!value);
+			else s += shape(value, childAt(at, k, value, deferred));
+		}
+		visiting.delete(v);
+		return s + (list ? "]" : "}");
+	};
+	const named = (v, at) => {
+		if (typeof v === "string") addRef(v, at);
+		return shape(v, at);
+	};
+	let s = typeof handler === "function" || handler == null ? shape(handler) : handler instanceof Response ? "R" : handler instanceof Promise ? "P" : typeof handler === "object" ? "O" : "V";
+	for (const event of shapeEvents) {
+		s += "|";
+		const fns = hook?.[event];
+		if (fns) for (const fn of Array.isArray(fns) ? fns : [fns]) s += shape(fn);
+	}
+	const bf = hook?.beforeHandle;
+	s += "|" + JSON.stringify(bf && require_compile_handler_utils.deriveModes(Array.isArray(bf) ? bf : [bf], hook["~deriveEntries"]));
+	for (const from of [hook, ...hook?.schemas || []]) for (const slot of shapeSlots) s += "|" + named(from?.[slot], slot);
+	let targets;
+	for (const [ref, at] of refs) for (const target of at ? (targets ??= require_utils.refTargets([], models))(ref) : [models?.[ref]]) s += "|" + JSON.stringify(ref) + shape(target, at);
+	s += "|" + JSON.stringify([
+		config?.cookie?.sign,
+		config?.cookie?.verify,
+		config?.normalize,
+		!!config?.allowUnsafeValidationDetails,
+		config?.abortSignal !== false,
+		require_utils.isNotEmpty(frozenRoot["~ext"]?.headers),
+		!!(config?.adapter ?? require_adapter_constants.defaultAdapter).response.supportsDefaultHeaderSink,
+		!!require_handler_utils.returnedErrorClasses(hook, root)
+	]) + shape(config?.sanitize);
+	return unsupported ? void 0 : require_utils.fnv1a(s);
+}
 const isBareArrow = /^(?:async\s*)?\(\s*\)\s*=>/;
 const isSucroseOpaque = /arguments|eval|\[native code\]/;
 function compileHandler(route, root, liveOnly = false) {
@@ -303,17 +417,7 @@ function compileHandler(route, root, liveOnly = false) {
 		handler = (c) => handle(new Request(require_utils.replaceUrlPath(c.request.url, c.path.slice(c.path.startsWith(encRoot) ? encLen : rawLen) || "/"), c.request));
 	}
 	const reconstructed = liveOnly ? void 0 : require_compile_aot.Compiled.getHandler(frozenRoot["~programId"], method, path);
-	if (reconstructed && typeof handler === "function" && !frozenRoot["~ext"]?.macro && !require_generation.frozenRootOf(localMacroRoot(macroScope ?? instance, root))["~ext"]?.macro) {
-		if (!reconstructed.a.some((name) => hookStateAliases.includes(name))) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
-			root,
-			parse: adapter.parse,
-			res: adapter.response,
-			hook: require_utils.nullObject(),
-			vali: void 0,
-			cookieConfig: void 0,
-			tracers: void 0
-		}));
-	}
+	if (!reconstructed) liveOnly ||= require_compile_aot.Compiled.hasProgram(frozenRoot["~programId"]);
 	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, !reconstructed);
 	if (hook) {
 		promoteDerive(hook);
@@ -351,6 +455,20 @@ function compileHandler(route, root, liveOnly = false) {
 		const resolve = (p) => typeof p === "string" && p in namedParsers ? namedParsers[p] : p;
 		hook.parse = Array.isArray(hook.parse) ? hook.parse.map(resolve) : resolve(hook.parse);
 	}
+	let shape;
+	if (reconstructed || require_compile_aot.Capture.isCapturing()) {
+		shape = routeShape(hook, handler, root);
+		if (reconstructed && (!shape || reconstructed.k !== shape)) {
+			let live;
+			try {
+				live = compileHandler(route, root, true);
+			} catch (cause) {
+				throw new Error(require_compile_aot.aotDrift(method, path), { cause });
+			}
+			require_compile_aot.warnAotDrift(method, path);
+			return live;
+		}
+	}
 	if (reconstructed) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
 		root,
 		parse: adapter.parse,
@@ -402,7 +520,8 @@ function compileHandler(route, root, liveOnly = false) {
 		isStaticResponse,
 		isPromiseHandler,
 		errorClasses,
-		state
+		state,
+		shape
 	});
 }
 
@@ -415,4 +534,5 @@ exports.composeRouteHook = composeRouteHook;
 exports.localMacroRoot = localMacroRoot;
 exports.resolveLocalHook = resolveLocalHook;
 exports.resolveWSLocalHook = resolveWSLocalHook;
+exports.routeShape = routeShape;
 exports.setCaptureHeaderShorthand = require_compile_handler_jit.setCaptureHeaderShorthand;