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

package/dist/base.mjs

@@ -1,35 +1,20 @@
 import { isBun } from "./universal/constants.mjs";
 import { MethodMap, isDynamicRegex, needEncodeRegex } from "./constants.mjs";
-import { coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, flattenChain, fnOrigin, fnv1a, getLoosePath, hookToGuard, isEmpty, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, replaceUrlPath, schemaProperties } from "./utils.mjs";
+import { clonePlainDecorators, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, flattenChain, fnOrigin, fnv1a, getLoosePath, hookToGuard, isEmpty, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, replaceUrlPath, schemaProperties } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { env } from "./universal/env.mjs";
+import { Capture } from "./compile/aot.mjs";
+import { buildNativeStaticResponse, compileHandler, composeRouteHook } from "./compile/handler/index.mjs";
 import { buildWSRoute } from "./ws/route.mjs";
 import { BunAdapter } from "./adapter/bun/index.mjs";
 import { applyHoc, createFetchHandler } from "./handler/fetch.mjs";
-import { buildNativeStaticResponse, compileHandler, composeRouteHook } from "./compile/handler/index.mjs";
 import Memoirist from "memoirist";
 
 //#region src/base.ts
 const useNodesBuffer = [];
-const isPlainObject = (v) => {
-	if (!v || typeof v !== "object" || Array.isArray(v)) return false;
-	const proto = Object.getPrototypeOf(v);
-	return proto === Object.prototype || proto === null;
-};
-function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
-	const existing = seen.get(source);
-	if (existing) return existing;
-	const out = nullObject();
-	seen.set(source, out);
-	for (const key in source) {
-		const value = source[key];
-		out[key] = isPlainObject(value) ? clonePlainDecorators(value, seen) : value;
-	}
-	return out;
-}
 var Elysia = class Elysia {
-	#hasPlugin = false;
-	#hasGlobal = false;
+	#hasPlugin;
+	#hasGlobal;
 	#ready;
 	#pending = 0;
 	#error;
@@ -50,6 +35,7 @@ var Elysia = class Elysia {
 	}
 	#compiled;
 	#cachedRoutes;
+	#hasMapResponse;
 	constructor(config) {
 		this["~config"] = config;
 		this["~Prefix"] = config?.prefix;
@@ -170,23 +156,8 @@ var Elysia = class Elysia {
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
 	}
-	on(...args) {
-		if (args.length === 2) {
-			const [event, fn] = args;
-			if (event === "parse" && typeof fn === "string") {
-				const named = this["~ext"]?.parser?.[fn];
-				return this.#onBranch("parse", named ?? fn);
-			}
-			return this.#onBranch(event, fn);
-		}
-		if (args.length === 3) {
-			const [scope, event, fn] = args;
-			return this.#onBranch(event, scope, fn);
-		}
-		return this;
-	}
-	request(scopeOrFn, fn) {
-		return this.#onBranch("request", scopeOrFn, fn);
+	request(fn) {
+		return this.#on("request", fn, "global");
 	}
 	parse(scopeOrFnOrName, fn) {
 		if (fn === void 0 && typeof scopeOrFnOrName === "string") {
@@ -201,10 +172,24 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return this;
 	}
-	onStart(_listener) {
-		return this;
-	}
-	onStop(_listener) {
+	/**
+	* ### setup | Life cycle event
+	* Called after server is ready for serving
+	*
+	* ---
+	* @example
+	* ```typescript
+	* new Elysia()
+	*     .setup(({ server }) => {
+	*         console.log("Running at ${server?.url}:${server?.port}")
+	*     })
+	*     .listen(3000)
+	* ```
+	*/
+	setup(handler) {
+		const arr = this.#ext.setup ??= [];
+		if (Array.isArray(handler)) arr.push(...handler);
+		else arr.push(handler);
 		return this;
 	}
 	transform(scopeOrFn, fn) {
@@ -225,6 +210,7 @@ var Elysia = class Elysia {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
 	mapResponse(scopeOrFn, fn) {
+		this.#hasMapResponse = true;
 		return this.#onBranch("mapResponse", scopeOrFn, fn);
 	}
 	afterResponse(scopeOrFn, fn) {
@@ -286,15 +272,7 @@ var Elysia = class Elysia {
 		}
 	}
 	guard() {
-		if (arguments.length === 1) {
-			const arg = arguments[0];
-			let scope = "local";
-			if (arg && typeof arg === "object" && "as" in arg && arg.as) {
-				scope = arg.as;
-				delete arg.as;
-			}
-			return this.#guard(scope, arg);
-		}
+		if (arguments.length === 1) return this.#guard("local", arguments[0]);
 		if (arguments.length === 2) {
 			if (typeof arguments[1] === "function") return this.group("", arguments[0], arguments[1]);
 			return this.#guard(arguments[0], arguments[1]);
@@ -351,9 +329,8 @@ var Elysia = class Elysia {
 		const finalize = () => {
 			const childFlat = flattenChain(child["~hookChain"]);
 			const lifted = nullObject();
-			if (childFlat?.request) lifted.request = childFlat.request;
 			if (childFlat?.parse) lifted.parse = childFlat.parse;
-			if (lifted.request || lifted.parse) this.#pushHook(lifted);
+			if (lifted.parse) this.#pushHook(lifted);
 			return child;
 		};
 		if (child.pending) return this.#useAsync(child.modules.then(finalize));
@@ -391,7 +368,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	macro(macro) {
-		if (typeof macro === "function") throw new Error("Use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
 		const ext = this.#ext;
 		const m = ext.macro ??= nullObject();
 		for (const key in macro) if (typeof macro[key] === "object") macro[key] = hookToGuard(macro[key]);
@@ -487,7 +464,8 @@ var Elysia = class Elysia {
 			for (const plugin of app) this.#use(plugin);
 			return this;
 		}
-		if (app !== this && app.pending) return this.#useAsync(app.modules.then(() => app));
+		if (app === this) return this;
+		if (app.pending) return this.#useAsync(app.modules.then(() => app));
 		this.#use(app);
 		return this;
 	}
@@ -553,8 +531,9 @@ var Elysia = class Elysia {
 			}
 		}
 		const hookChain = app["~hookChain"];
+		if (!this.#hasMapResponse && app.#hasMapResponse) this.#hasMapResponse = true;
 		if (app["~ext"]) {
-			const { decorator, store, headers, models, parser, macro, error, hoc } = app["~ext"];
+			const { decorator, store, headers, models, parser, macro, error, hoc, setup, cleanup } = app["~ext"];
 			const ext = this["~ext"] ??= nullObject();
 			if (decorator) {
 				const cloned = clonePlainDecorators(decorator);
@@ -576,6 +555,12 @@ var Elysia = class Elysia {
 			if (hoc) if (ext.hoc) {
 				for (const fn of hoc) if (!ext.hoc.includes(fn)) ext.hoc.push(fn);
 			} else ext.hoc = hoc.slice();
+			if (setup) if (ext.setup) {
+				for (const fn of setup) if (!ext.setup.includes(fn)) ext.setup.push(fn);
+			} else ext.setup = setup.slice();
+			if (cleanup) if (ext.cleanup) {
+				for (const fn of cleanup) if (!ext.cleanup.includes(fn)) ext.cleanup.push(fn);
+			} else ext.cleanup = cleanup.slice();
 		}
 		if (app.#hasPlugin || app.#hasGlobal || hookChain) {
 			let pluginEvents;
@@ -826,18 +811,23 @@ var Elysia = class Elysia {
 	}
 	#initMap() {
 		this["~map"] ??= {
-			GET: nullObject(),
-			POST: nullObject(),
-			PUT: nullObject(),
-			DELETE: nullObject(),
-			PATCH: nullObject(),
-			HEAD: nullObject(),
-			OPTIONS: nullObject()
+			GET: void 0,
+			POST: void 0,
+			PUT: void 0,
+			DELETE: void 0,
+			PATCH: void 0,
+			HEAD: void 0,
+			OPTIONS: void 0
 		};
 	}
 	compile() {
 		this["~config"] ??= nullObject();
 		this["~config"].precompile = true;
+		this.#routerBuilt = false;
+		if (Capture.isCapturing()) {
+			this.#compiled = void 0;
+			this.#fetchFn = void 0;
+		}
 		this.fetch;
 		return this;
 	}
@@ -864,6 +854,7 @@ var Elysia = class Elysia {
 		};
 	}
 	#saveHandler(method, path, handler) {
+		if (isDynamicRegex.test(path)) return;
 		this.#initMap();
 		const map = this["~map"][mapMethodBack(method)] ??= nullObject();
 		map[path] = handler;
@@ -908,9 +899,9 @@ var Elysia = class Elysia {
 			for (let i = 0; i < length; i++) if (mapMethodBack(this.#history[i][0]) === "HEAD") (explicitHead ??= /* @__PURE__ */ new Set()).add(this.#history[i][1]);
 		}
 		const wrapHeadHandler = Elysia.#wrapHeadHandler;
-		const strict = !!this["~config"]?.strictPath;
+		const preferLoosePath = this["~config"]?.strictPath !== true;
 		let explicitPaths;
-		if (!strict) {
+		if (preferLoosePath && this["~config"]?.distinctPath) {
 			explicitPaths = /* @__PURE__ */ new Map();
 			for (let i = 0; i < length; i++) {
 				const route = this.#history[i];
@@ -933,7 +924,7 @@ var Elysia = class Elysia {
 				const ws = buildWSRoute(route, this);
 				const handler = ws[0];
 				const options = ws[1];
-				if (isDynamicRegex.test(path)) (this["~router"] ??= new Memoirist()).add("WS", path, handler, false);
+				if (isDynamicRegex.test(path)) (this["~router"] ??= new Memoirist({ loosePath: preferLoosePath })).add("WS", path, handler, false);
 				else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= nullObject();
@@ -960,51 +951,70 @@ var Elysia = class Elysia {
 			let staticResponse;
 			const maybeStatic = buildStatic && typeof route[2] !== "function";
 			if (maybeStatic) {
-				staticResponse = buildNativeStaticResponse(route, this);
+				staticResponse = buildNativeStaticResponse(route, this, this.#hasMapResponse);
 				if (staticResponse) {
-					const target = this["~staticResponse"] ??= nullObject();
-					(target[path] ??= nullObject())[method] = staticResponse;
+					const target = this["~staticResponse"] ??= {
+						GET: void 0,
+						POST: void 0,
+						PUT: void 0,
+						DELETE: void 0,
+						PATCH: void 0,
+						HEAD: void 0,
+						OPTIONS: void 0
+					};
+					(target[method] ??= nullObject())[path] = staticResponse;
 					if (!this["~config"]?.strictPath) {
 						const loose = getLoosePath(path);
-						if (!explicitPaths?.get(method)?.has(loose)) (target[loose] ??= nullObject())[method] = staticResponse;
+						if (!explicitPaths?.get(method)?.has(loose)) (target[method] ??= nullObject())[loose] = staticResponse;
 					}
 				}
 			}
 			const sharedStatic = maybeStatic && staticResponse instanceof Response ? staticResponse : void 0;
 			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
-			const registerPattern = (registerMain, registerHead, handler, headHandler, registerLoose) => {
-				const explicitMain = explicitPaths?.get(method);
-				const add = (p) => {
-					registerMain(p, handler);
-					if (headHandler) registerHead(p, headHandler);
-					if (registerLoose) {
-						const loose = getLoosePath(p);
-						if (loose !== p && !explicitMain?.has(loose)) {
-							registerMain(loose, handler);
-							if (headHandler) registerHead(loose, headHandler);
-						}
-					}
-				};
-				add(path);
-				if (needEncodeRegex.test(path)) {
-					const encoded = encodeURI(path);
-					if (encoded !== path) add(encoded);
+			const isDynamic = isDynamicRegex.test(path);
+			const registerLoose = !isDynamic && preferLoosePath && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+			const explicitMain = registerLoose ? explicitPaths?.get(method) : void 0;
+			if (!isDynamic && !needEncodeRegex.test(path) && !registerLoose) {
+				const map = methods[method] ??= nullObject();
+				const handler = this.handler(i, precompile, route, sharedStatic);
+				map[path] = handler;
+				if (autoHead) {
+					const head = methods["HEAD"] ??= nullObject();
+					head[path] = wrapHeadHandler(handler);
 				}
-			};
-			if (isDynamicRegex.test(path)) {
-				const router = this["~router"] ??= new Memoirist();
+				continue;
+			}
+			const variants = [path];
+			if (needEncodeRegex.test(path)) {
+				const encoded = encodeURI(path);
+				if (encoded !== path) variants.push(encoded);
+			}
+			const paths = [];
+			for (let v = 0; v < variants.length; v++) {
+				const p = variants[v];
+				paths.push(p);
+				if (registerLoose) {
+					const loose = getLoosePath(p);
+					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
+				}
+			}
+			if (isDynamic) {
+				const router = this["~router"] ??= new Memoirist({ loosePath: preferLoosePath });
 				const handler = this.handler(i, precompile, void 0, sharedStatic);
-				registerPattern((p, h) => router.add(method, p, h, false), (p, h) => router.add("HEAD", p, h, false), handler, autoHead ? wrapHeadHandler(handler) : void 0, false);
+				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
+				for (let p = 0; p < paths.length; p++) {
+					router.add(method, paths[p], handler, false);
+					if (headHandler) router.add("HEAD", paths[p], headHandler, false);
+				}
 			} else {
 				const map = methods[method] ??= nullObject();
 				const handler = this.handler(i, precompile, route, sharedStatic);
 				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
 				const head = autoHead ? methods["HEAD"] ??= nullObject() : void 0;
-				registerPattern((p, h) => {
-					map[p] = h;
-				}, (p, h) => {
-					head[p] = h;
-				}, handler, headHandler, !strict);
+				for (let p = 0; p < paths.length; p++) {
+					map[paths[p]] = handler;
+					if (headHandler) head[paths[p]] = headHandler;
+				}
 			}
 		}
 	}
@@ -1029,13 +1039,33 @@ var Elysia = class Elysia {
 		return this;
 	}
 	wrap(callback) {
-		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built, so it will not take effect. Register .wrap() before .listen() or before accessing .fetch/.handle.");
+		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
 		const ext = this.#ext;
 		(ext.hoc ??= []).push(callback);
 		return this;
 	}
 	/**
-	* Stop the underlying server (if any). Mirrors `Server.stop()`.
+	* ### cleanup | Life cycle event
+	* Called after server stop serving request
+	*
+	* ---
+	* @example
+	* ```typescript
+	* new Elysia()
+	*     .cleanup((app) => {
+	*         closeDatabase()
+	*     })
+	* ```
+	*/
+	cleanup(handler) {
+		const arr = this.#ext.cleanup ??= [];
+		if (Array.isArray(handler)) arr.push(...handler);
+		else arr.push(handler);
+		return this;
+	}
+	/**
+	* Stop the underlying server (if any), running every `cleanup` handler once
+	* it has stopped. Mirrors `Server.stop()`.
 	*
 	* @param closeActiveConnections Pass `true` to terminate in-flight
 	*   requests and WebSocket connections immediately. Defaults to
@@ -1046,6 +1076,12 @@ var Elysia = class Elysia {
 		if (!server) return;
 		const r = server.stop?.(closeActiveConnections);
 		this.server = void 0;
+		const handlers = this["~ext"]?.cleanup;
+		const fire = handlers ? () => {
+			for (let i = 0; i < handlers.length; i++) handlers[i](this);
+		} : void 0;
+		if (r && typeof r.then === "function") return fire ? r.then(fire) : r;
+		fire?.();
 		return r;
 	}
 };

package/dist/compile/aot.d.ts

@@ -1,3 +1,5 @@
+import { CoercePlan } from "../type/coerce.js";
+
 //#region src/compile/aot.d.ts
 type ValidatorSlot = 'body' | 'query' | 'params' | 'headers' | 'cookie' | `response:${number}`;
 type FrozenCheckFactory = (External: unknown) => (value: unknown) => boolean;
@@ -31,7 +33,10 @@ interface FrozenValidator {
   r?: 1;
   ps?: 1;
   pd?: unknown;
+  pn?: 1;
   pod?: Record<string, unknown>;
+  dc?: () => unknown;
+  pm?: (value: Record<string, unknown>) => Record<string, unknown>;
   ce?: Array<{
     p: string;
     c: FrozenCheckFactory;
@@ -45,6 +50,7 @@ interface FrozenValidator {
       x?: 1;
     };
   }>;
+  cp?: CoercePlan;
 }
 interface ValidatorManifest {
   [method: string]: {
@@ -60,6 +66,13 @@ interface HandlerManifest {
     [path: string]: FrozenHandler;
   };
 }
+interface CompiledSnapshot {
+  validators: ValidatorManifest | undefined;
+  handlers: HandlerManifest | undefined;
+  lazyGroups: Array<() => ValidatorManifest> | undefined;
+  lazyGroupOf: Record<string, Record<string, number>> | undefined;
+  builtGroups: number[];
+}
 declare abstract class Compiled {
   static get handlers(): HandlerManifest | undefined;
   static set handlers(manifest: HandlerManifest);
@@ -68,6 +81,10 @@ declare abstract class Compiled {
   static registerLazyValidators(groups: Array<() => ValidatorManifest>, groupOf: Record<string, Record<string, number>>): void;
   static getValidator(method: string, path: string, slot: ValidatorSlot): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot): boolean;
+  /** @internal preserve registry around in-process AOT analysis */
+  static snapshot(): CompiledSnapshot;
+  /** @internal restore registry after in-process AOT analysis */
+  static restore(snapshot: CompiledSnapshot): void;
   /** @internal test isolation */
   static clear(): void;
 }
@@ -142,7 +159,10 @@ interface CapturedValidator {
   encodeMirror?: CapturedMirror;
   precomputeSafe?: boolean;
   precomputedDefault?: unknown;
+  precomputeNull?: boolean;
   precomputedObjectDefault?: Record<string, unknown>;
+  defaultCloner?: string;
+  objectDefaultMerger?: string;
   customErrors?: Array<{
     path: string;
     identifier: string;
@@ -158,6 +178,7 @@ interface CapturedValidator {
     external: boolean;
     decode: CapturedMirror;
   }>;
+  coercePlan?: CoercePlan;
 }
 declare function beginValidatorCapture(): void;
 declare function endValidatorCapture(): CapturedValidator[];
@@ -182,4 +203,4 @@ declare const Capture: {
   readonly isCapturing: () => boolean;
 };
 //#endregion
-export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck };
+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 };

package/dist/compile/aot.js

@@ -20,6 +20,9 @@ var Compiled = class {
 	}
 	static set validators(manifest) {
 		validators = manifest;
+		lazyGroups = void 0;
+		lazyGroupOf = void 0;
+		builtGroups.clear();
 	}
 	static registerLazyValidators(groups, groupOf) {
 		lazyGroups = groups;
@@ -45,6 +48,25 @@ var Compiled = class {
 	static hasValidator(method, path, slot) {
 		return validators?.[method]?.[path]?.[slot] !== void 0 || lazyGroupOf?.[method]?.[path] !== void 0;
 	}
+	/** @internal preserve registry around in-process AOT analysis */
+	static snapshot() {
+		return {
+			validators,
+			handlers,
+			lazyGroups,
+			lazyGroupOf,
+			builtGroups: [...builtGroups]
+		};
+	}
+	/** @internal restore registry after in-process AOT analysis */
+	static restore(snapshot) {
+		validators = snapshot.validators;
+		handlers = snapshot.handlers;
+		lazyGroups = snapshot.lazyGroups;
+		lazyGroupOf = snapshot.lazyGroupOf;
+		builtGroups.clear();
+		for (const group of snapshot.builtGroups) builtGroups.add(group);
+	}
 	/** @internal test isolation */
 	static clear() {
 		validators = void 0;

package/dist/compile/aot.mjs

@@ -19,6 +19,9 @@ var Compiled = class {
 	}
 	static set validators(manifest) {
 		validators = manifest;
+		lazyGroups = void 0;
+		lazyGroupOf = void 0;
+		builtGroups.clear();
 	}
 	static registerLazyValidators(groups, groupOf) {
 		lazyGroups = groups;
@@ -44,6 +47,25 @@ var Compiled = class {
 	static hasValidator(method, path, slot) {
 		return validators?.[method]?.[path]?.[slot] !== void 0 || lazyGroupOf?.[method]?.[path] !== void 0;
 	}
+	/** @internal preserve registry around in-process AOT analysis */
+	static snapshot() {
+		return {
+			validators,
+			handlers,
+			lazyGroups,
+			lazyGroupOf,
+			builtGroups: [...builtGroups]
+		};
+	}
+	/** @internal restore registry after in-process AOT analysis */
+	static restore(snapshot) {
+		validators = snapshot.validators;
+		handlers = snapshot.handlers;
+		lazyGroups = snapshot.lazyGroups;
+		lazyGroupOf = snapshot.lazyGroupOf;
+		builtGroups.clear();
+		for (const group of snapshot.builtGroups) builtGroups.add(group);
+	}
 	/** @internal test isolation */
 	static clear() {
 		validators = void 0;

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

@@ -1,10 +1,10 @@
 import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { ChainNode } from "../../utils.js";
 import { AnyElysia } from "../../base.js";
+import { setCaptureHeaderShorthand } from "./jit.js";
 
 //#region src/compile/handler/index.d.ts
-declare const setCaptureHeaderShorthand: (value: boolean | undefined) => void;
-declare function buildNativeStaticResponse([,, handler, instance, localHook, appHook, inheritedChain]: InternalRoute, root: AnyElysia): Response | Promise<Response> | undefined;
+declare function buildNativeStaticResponse([,, handler, instance, localHook, appHook, inheritedChain]: InternalRoute, root: AnyElysia, hasMapResponse?: boolean): Response | Promise<Response> | undefined;
 declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia): AnyLocalHook | undefined;
 declare function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain]: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;
 //#endregion