elysia 2.0.0-exp.40 → 2.0.0-exp.41

package/dist/adapter/bun/index.js

@@ -21,7 +21,7 @@ function collectStaticRoutes(app) {
 	const seen = /* @__PURE__ */ new Map();
 	for (let i = 0; i < history.length; i++) {
 		const route = history[i];
-		const method = route[0] === "WS" ? "WS" : require_utils.mapMethodBack(route[0]);
+		const method = route[0];
 		seen.set(method + " " + route[1], i);
 	}
 	let explicitPaths;
@@ -29,7 +29,7 @@ function collectStaticRoutes(app) {
 		explicitPaths = /* @__PURE__ */ new Map();
 		for (let i = 0; i < history.length; i++) {
 			const route = history[i];
-			const method = route[0] === "WS" ? "WS" : require_utils.mapMethodBack(route[0]);
+			const method = route[0];
 			const path = route[1];
 			let set = explicitPaths.get(method);
 			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
@@ -52,7 +52,7 @@ function collectStaticRoutes(app) {
 	for (let i = 0; i < history.length; i++) {
 		const route = history[i];
 		if (route[0] === "WS") continue;
-		const method = require_utils.mapMethodBack(route[0]);
+		const method = route[0];
 		const path = route[1];
 		if (seen.get(method + " " + path) !== i) continue;
 		const value = require_compile_handler_index.buildNativeStaticResponse(route, app);

package/dist/adapter/bun/index.mjs

@@ -1,6 +1,6 @@
 import { createAdapter } from "../index.mjs";
 import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
-import { flattenChain, getLoosePath, mapMethodBack, nullObject } from "../../utils.mjs";
+import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
 import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
 import { flushMemory } from "../../memory.mjs";
@@ -20,7 +20,7 @@ function collectStaticRoutes(app) {
 	const seen = /* @__PURE__ */ new Map();
 	for (let i = 0; i < history.length; i++) {
 		const route = history[i];
-		const method = route[0] === "WS" ? "WS" : mapMethodBack(route[0]);
+		const method = route[0];
 		seen.set(method + " " + route[1], i);
 	}
 	let explicitPaths;
@@ -28,7 +28,7 @@ function collectStaticRoutes(app) {
 		explicitPaths = /* @__PURE__ */ new Map();
 		for (let i = 0; i < history.length; i++) {
 			const route = history[i];
-			const method = route[0] === "WS" ? "WS" : mapMethodBack(route[0]);
+			const method = route[0];
 			const path = route[1];
 			let set = explicitPaths.get(method);
 			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
@@ -51,7 +51,7 @@ function collectStaticRoutes(app) {
 	for (let i = 0; i < history.length; i++) {
 		const route = history[i];
 		if (route[0] === "WS") continue;
-		const method = mapMethodBack(route[0]);
+		const method = route[0];
 		const path = route[1];
 		if (seen.get(method + " " + path) !== i) continue;
 		const value = buildNativeStaticResponse(route, app);

package/dist/base.d.ts

@@ -57,14 +57,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~scopeChild'?: boolean;
   '~scopeChildren'?: AnyElysia[];
   constructor(config?: ElysiaConfig<BasePath, Scope>);
-  /**
-   * @deprecated use `app.history` instead
-   *
-   * Elysia changes it store route internally
-   * This API is provided as compatibility
-   *
-   * Will remove in 2.1
-   */
   get routes(): PublicRoute[];
   /**
    * ### decorate
@@ -868,4 +860,4 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   stop(closeActiveConnections?: boolean): Promise<void> | void;
 }
 //#endregion
-export { AnyElysia, Elysia };
+export { AnyElysia, Elysia, StaticMapAliases };

package/dist/base.js

@@ -6,9 +6,9 @@ const require_utils = require('./utils.js');
 const require_type_bridge = require('./type/bridge.js');
 const require_compile_aot = require('./compile/aot.js');
 const require_compile_handler_index = require('./compile/handler/index.js');
-const require_ws_route = require('./ws/route.js');
 const require_adapter_bun_index = require('./adapter/bun/index.js');
 const require_handler_fetch = require('./handler/fetch.js');
+const require_compile_build_router = require('./compile/build-router.js');
 let memoirist = require("memoirist");
 memoirist = require_runtime.__toESM(memoirist);
 
@@ -54,14 +54,6 @@ var Elysia = class Elysia {
 		if (this["~Prefix"] && !this["~Prefix"].startsWith("/")) this["~Prefix"] = `/${this["~Prefix"]}`;
 		if (config?.name) this.#hash = require_utils.fnv1a(config.seed ? `${config.name}_${typeof config.seed === "object" ? JSON.stringify(config.seed) : config.seed}` : config.name);
 	}
-	/**
-	* @deprecated use `app.history` instead
-	*
-	* Elysia changes it store route internally
-	* This API is provided as compatibility
-	*
-	* Will remove in 2.1
-	*/
 	get routes() {
 		if (!this.#history) return [];
 		if (this.#cachedRoutes) return this.#cachedRoutes;
@@ -73,7 +65,7 @@ var Elysia = class Elysia {
 			}
 			if (merged?.response && !require_utils.isRecordNumber(merged.response)) merged.response = { 200: merged.response };
 			return {
-				method: require_utils.mapMethodBack(method),
+				method,
 				path,
 				handler,
 				hooks: merged
@@ -851,25 +843,25 @@ var Elysia = class Elysia {
 		return require_type_bridge.Ref(key);
 	}
 	get(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.GET, path, hookOrFn, fn);
+		return this.#add("GET", path, hookOrFn, fn);
 	}
 	post(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.POST, path, hookOrFn, fn);
+		return this.#add("POST", path, hookOrFn, fn);
 	}
 	put(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.PUT, path, hookOrFn, fn);
+		return this.#add("PUT", path, hookOrFn, fn);
 	}
 	patch(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.PATCH, path, hookOrFn, fn);
+		return this.#add("PATCH", path, hookOrFn, fn);
 	}
 	delete(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.DELETE, path, hookOrFn, fn);
+		return this.#add("DELETE", path, hookOrFn, fn);
 	}
 	options(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.OPTIONS, path, hookOrFn, fn);
+		return this.#add("OPTIONS", path, hookOrFn, fn);
 	}
 	head(path, hookOrFn, fn) {
-		return this.#add(require_constants.MethodMap.HEAD, path, hookOrFn, fn);
+		return this.#add("HEAD", path, hookOrFn, fn);
 	}
 	method(method, path, hookOrFn, fn) {
 		return this.#add(method, path, hookOrFn, fn);
@@ -959,7 +951,7 @@ var Elysia = class Elysia {
 			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 });
+				throw new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
 			}
 			compiled[index] = handler;
 			this.#saveHandler(route[0], route[1], handler);
@@ -974,7 +966,7 @@ var Elysia = class Elysia {
 			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 });
+				throw new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
 			}
 			this.#compiled[index] = handler;
 			if (aliases) {
@@ -993,7 +985,7 @@ var Elysia = class Elysia {
 	#saveHandler(method, path, handler) {
 		if (require_constants.isDynamicRegex.test(path)) return;
 		this.#initMap();
-		const map = this["~map"][require_utils.mapMethodBack(method)] ??= require_utils.nullObject();
+		const map = this["~map"][method] ??= require_utils.nullObject();
 		map[path] = handler;
 	}
 	static #toHeadResponse(response) {
@@ -1021,203 +1013,76 @@ 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;
-			}
+	#replayRouter(routeTableManifest) {
+		if (routeTableManifest.v !== 1) return false;
+		const history = this.#history;
+		if (require_compile_aot.computeRouteTableShape(history, this["~config"]) !== routeTableManifest.shape) throw new Error(`[elysia-aot] frozen route-table shape mismatch`);
+		this.#initMap();
+		const methods = this["~map"];
+		this.#compiled ??= new Array(history.length);
+		const indexOf = /* @__PURE__ */ new Map();
+		for (let i = 0; i < history.length; i++) {
+			const route = history[i];
+			indexOf.set(route[0] + "\0" + route[1], i);
 		}
-		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;
+		const handlerFor = (slot) => {
+			const i = indexOf.get(slot.m + "\0" + slot.p);
+			if (i === void 0) return;
+			return this.handler(i, true, history[i]);
+		};
+		let bound = 0;
+		let expected = 0;
+		const staticTree = routeTableManifest.static;
+		for (const method in staticTree) {
+			const paths = staticTree[method];
+			const map = methods[method] ??= require_utils.nullObject();
+			for (const served in paths) {
+				expected++;
+				const handler = handlerFor(paths[served]);
+				if (handler === void 0) continue;
+				map[served] = handler;
+				bound++;
+			}
 		}
-		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);
+		const headTree = routeTableManifest.head;
+		if (headTree) {
+			const head = methods["HEAD"] ??= require_utils.nullObject();
+			for (const served in headTree) {
+				expected++;
+				const handler = handlerFor(headTree[served]);
+				if (handler === void 0) continue;
+				head[served] = Elysia.#wrapHeadHandler(handler);
+				bound++;
 			}
 		}
-		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];
-		const checkSlots = (hook) => {
-			if (!hook) return;
-			for (const key in hook) {
-				if (!require_utils.schemaProperties.has(key)) continue;
-				const v = hook[key];
-				if (typeof v === "string") {
-					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}.`);
-				} else 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) {
-						const r = record[status];
-						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}.`);
-					}
-				}
+		const dynamicList = routeTableManifest.dynamic;
+		if (dynamicList) {
+			const router = this["~router"] ??= new memoirist.default({ loosePath: this["~config"]?.strictPath !== true });
+			for (let d = 0; d < dynamicList.length; d++) {
+				expected++;
+				const entry = dynamicList[d];
+				const base = handlerFor(entry.slot);
+				if (base === void 0) continue;
+				router.add(entry.m, entry.s, entry.h ? Elysia.#wrapHeadHandler(base) : base, false);
+				bound++;
 			}
-		};
-		const hook = require_compile_handler_index.composeRouteHook(route[3], route[4], route[5], route[6], this, route[7]);
-		checkSlots(hook);
-		const schemas = hook?.schemas;
-		if (Array.isArray(schemas)) for (let s = 0; s < schemas.length; s++) checkSlots(schemas[s]);
+		}
+		if (bound < expected) throw new Error(`[elysia-aot] frozen route-table bound ${bound}/${expected} routes`);
+		this.#routerBuilt = true;
+		return true;
 	}
 	#routerBuilt = false;
 	#buildRouter() {
 		if (!this.#history || this.#routerBuilt) return;
+		const routeTableManifest = require_compile_aot.Capture.isAotBuildEnv() ? void 0 : require_compile_aot.Compiled.routeTable;
+		if (routeTableManifest && this.#replayRouter(routeTableManifest)) return;
 		this.#routerBuilt = true;
-		const precompile = this["~config"]?.precompile;
-		const enableAutoHead = this["~config"]?.autoHead === true;
-		this.#initMap();
-		const methods = this["~map"];
-		const length = this.#history.length;
-		const wrapHeadHandler = Elysia.#wrapHeadHandler;
-		const isLoose = this["~config"]?.strictPath !== true;
-		let explicitHead;
-		let explicitPaths;
-		if (isLoose) explicitPaths = /* @__PURE__ */ new Map();
-		if (enableAutoHead || isLoose) for (let i = 0; i < length; i++) {
-			const route = this.#history[i];
-			const isWS = route[0] === "WS";
-			const m = isWS ? "WS" : require_utils.mapMethodBack(route[0]);
-			const p = route[1];
-			if (enableAutoHead && !isWS && m === "HEAD") (explicitHead ??= /* @__PURE__ */ new Set()).add(p);
-			if (explicitPaths) {
-				let set = explicitPaths.get(m);
-				if (!set) explicitPaths.set(m, set = /* @__PURE__ */ new Set());
-				set.add(p);
-				if (require_constants.needEncodeRegex.test(p)) {
-					const encoded = encodeURI(p);
-					if (encoded !== p) set.add(encoded);
-				}
-			}
-		}
-		for (let i = 0; i < length; i++) {
-			const route = this.#history[i];
-			const method = require_utils.mapMethodBack(route[0]);
-			const path = route[1];
-			if (this.#routeMayHaveModelRef(route)) this.#assertRouteModelRefs(route, method);
-			if (route[0] === "WS") {
-				const ws = require_ws_route.buildWSRoute(route, this);
-				const handler = ws[0];
-				const options = ws[1];
-				if (require_constants.isDynamicRegex.test(path)) {
-					(this["~router"] ??= new memoirist.default({ loosePath: isLoose })).add("WS", path, handler, false);
-					this["~hasDynamicWS"] = true;
-				} else {
-					this.#initMap();
-					const wsMap = this["~map"]["WS"] ??= require_utils.nullObject();
-					wsMap[path] = handler;
-					if (isLoose) {
-						const loose = require_utils.getLoosePath(path);
-						if (loose !== path && !explicitPaths?.get("WS")?.has(loose)) wsMap[loose] = handler;
-					}
-				}
-				if (options && require_utils.isNotEmpty(options)) {
-					this["~config"] ??= require_utils.nullObject();
-					const existing = this["~config"].websocket;
-					if (existing && require_universal_constants.isBun) {
-						for (const key in options) if (key in existing && existing[key] !== options[key]) {
-							console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (the last-registered route wins).`);
-							console.warn((/* @__PURE__ */ new Error()).stack);
-						}
-						Object.assign(existing, options);
-					} else this["~config"].websocket = options;
-				}
-				continue;
-			}
-			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
-			const isDynamic = require_constants.isDynamicRegex.test(path);
-			const needsEncode = require_constants.needEncodeRegex.test(path);
-			const registerLoose = !isDynamic && isLoose && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
-			const explicitMain = registerLoose ? explicitPaths?.get(method) : void 0;
-			if (!isDynamic && !needsEncode && !registerLoose) {
-				const map = methods[method] ??= require_utils.nullObject();
-				const handler = this.handler(i, precompile, route, void 0, autoHead ? {
-					method,
-					paths: [path],
-					head: true
-				} : void 0);
-				map[path] = handler;
-				if (autoHead) {
-					const head = methods["HEAD"] ??= require_utils.nullObject();
-					head[path] = wrapHeadHandler(handler);
-				}
-				continue;
-			}
-			const variants = [path];
-			if (needsEncode) {
-				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 = require_utils.getLoosePath(p);
-					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
-				}
-			}
-			if (isDynamic) {
-				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
-				const handler = this.handler(i, precompile, void 0, void 0);
-				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] ??= require_utils.nullObject();
-				const handler = this.handler(i, precompile, route, void 0, {
-					method,
-					paths,
-					head: autoHead
-				});
-				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
-				const head = autoHead ? methods["HEAD"] ??= require_utils.nullObject() : void 0;
-				for (let p = 0; p < paths.length; p++) {
-					map[paths[p]] = handler;
-					if (headHandler) head[paths[p]] = headHandler;
-				}
-			}
-		}
+		require_compile_build_router.buildRouter(this, {
+			history: this.#history,
+			handler: (index, immediate, route, precomputedStatic, aliases) => this.handler(index, immediate, route, precomputedStatic, aliases),
+			initMap: () => this.#initMap(),
+			wrapHeadHandler: Elysia.#wrapHeadHandler
+		});
 	}
 	#fetchFn;
 	get fetch() {