elysia 2.0.0-exp.5 → 2.0.0-exp.51

package/dist/_virtual/_rolldown/runtime.js

@@ -5,19 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -39,5 +26,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
-exports.__exportAll = __exportAll;
 exports.__toESM = __toESM;

package/dist/_virtual/_rolldown/runtime.mjs

@@ -1,3 +1,5 @@
+import { createRequire } from "node:module";
+
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

package/dist/adapter/bun/index.d.ts

@@ -1,30 +1,7 @@
-import { ListenCallback, Serve } from "../../universal/server.js";
-import { AnyLocalHook, MaybePromise } from "../../types.js";
-import { Context } from "../../context.js";
 import { AnyElysia } from "../../base.js";
+import { ElysiaAdapterOptions } from "../types.js";
 //#region src/adapter/bun/index.d.ts
-declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, Promise<void>[]] | undefined;
-declare const BunAdapter: {
-  parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
-    json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
-    text: (context: Context) => MaybePromise<string>;
-    urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
-    arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
-    formData: (context: Context) => MaybePromise<Record<string, unknown>>;
-  };
-  name: string;
-  runtime: "node" | "deno" | "bun" | "cloudflare-worker" | "browser" | "vercel" | "netlify" | "lambda" | "fastly" | "edge" | "unknown" | (string & {});
-  isWebStandard: boolean;
-  listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
-  stop?(app: AnyElysia, closeActiveConnections?: boolean): Promise<void>;
-  response: {
-    map(response: unknown, set: Context["set"], ...params: unknown[]): unknown;
-    compact?(response: unknown, ...params: unknown[]): unknown;
-    static?(handle: unknown, hooks: AnyLocalHook, setHeaders?: Context["set"]["headers"], ...params: unknown[]): (() => unknown) | undefined;
-    nativeStatic?(handle: unknown, hooks: AnyLocalHook, set?: Context["set"]): (() => MaybePromise<Response>) | undefined;
-  };
-  fetch?(app: AnyElysia): (request: Request) => MaybePromise<Response>;
-};
+declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, readonly []] | undefined;
+declare const BunAdapter: ElysiaAdapterOptions;
 //#endregion
 export { BunAdapter, collectStaticRoutes };

package/dist/adapter/bun/index.js

@@ -1,84 +1,223 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_adapter_index = require('../index.js');
+const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
 const require_adapter_web_standard_index = require('../web-standard/index.js');
-const require_memory = require('../../memory.js');
-const require_ws_route = require('../../ws/route.js');
+const require_generation = require('../../generation.js');
+const require_compile_handler_index = require('../../compile/handler/index.js');
+const require_route_table = require('../../route-table.js');
+const require_adapter_origin = require('../origin.js');
 
 //#region src/adapter/bun/index.ts
+/**
+* ! This may looks like it would cause race condition, but it is not
+* Bun is single-threaded and synchronous, so the `finally` block will
+* always run before the next request comes in
+* @see ../origin.ts
+*
+* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
+* before its first suspension, that it holds the untouched original and may
+* defer materializing `request.signal`
+*
+* `finally` runs on the synchronous return of `fetch` (the returned promise is
+* not awaited), so the slot is live only for the handler's synchronous prologue.
+*/
+const withOrigin = (fetch) => (request, server) => {
+	require_adapter_origin.origin.request = request;
+	try {
+		return fetch(request, server);
+	} finally {
+		require_adapter_origin.origin.request = void 0;
+	}
+};
+const nativeStaticMethods = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS"
+]);
 function collectStaticRoutes(app) {
-	if (app["~ext"]?.hoc?.length) return;
-	const hook = require_utils.flattenChain(app["~hookChain"]);
-	if (hook && (hook?.request?.length || hook?.mapResponse?.length || hook?.afterResponse?.length || hook?.trace?.length)) return;
+	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
-	const source = app["~staticResponse"];
-	if (!source) return;
+	const frozenRoot = require_generation.frozenRootOf(app);
+	const fetchLevelHook = require_utils.flattenChain(frozenRoot["~hookChain"]);
+	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
+	const length = table?.length ?? 0;
+	if (!table || !length) return;
+	const methods = table.method;
+	const paths = table.path;
+	const handlers = table.handler;
+	let hasCandidate = false;
+	for (let i = 0; i < length; i++) {
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		if (!nativeStaticMethods.has(methods[i])) continue;
+		hasCandidate = true;
+		break;
+	}
+	if (!hasCandidate) return;
 	const ready = require_utils.nullObject();
-	const pending = [];
-	for (const rawPath in source) {
-		const path = encodeURI(rawPath);
-		const methods = source[rawPath];
-		for (const method in methods) {
-			const value = methods[method];
-			if (value instanceof Promise) pending.push(value.then((resolved) => {
-				if (resolved instanceof Response) (ready[path] ??= require_utils.nullObject())[method] = resolved;
-			}, (err) => {
-				console.error(`[Elysia] Static route ${method} ${path} failed to resolve:`, err);
-			}));
-			else (ready[path] ??= require_utils.nullObject())[method] = value;
+	const strictPath = frozenRoot["~config"]?.strictPath === true;
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
+	let explicitPaths;
+	if (!strictPath) {
+		explicitPaths = /* @__PURE__ */ new Map();
+		for (let i = 0; i < length; i++) {
+			const method = methods[i];
+			const path = paths[i];
+			let set = explicitPaths.get(method);
+			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
+			set.add(path);
+			if (require_constants.needEncodeRegex.test(path)) {
+				const encoded = encodeURI(path);
+				if (encoded !== path) set.add(encoded);
+			}
 		}
 	}
-	return [ready, pending];
+	const add = (method, path, value) => {
+		if (require_constants.needEncodeRegex.test(path)) path = encodeURI(path);
+		(ready[path] ??= require_utils.nullObject())[method] = value;
+	};
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (method === "WS") continue;
+		const path = paths[i];
+		if (seen.get(method + " " + path) !== i) continue;
+		if (!nativeStaticMethods.has(method)) continue;
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		const value = require_compile_handler_index.buildNativeStaticResponse(require_route_table.routeRow(table, i), app);
+		if (!value) continue;
+		add(method, path, value);
+		if (!strictPath && !require_constants.isDynamicRegex.test(path)) {
+			const loose = require_utils.getLoosePath(path);
+			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
+		}
+	}
+	if (!Object.keys(ready).length) return;
+	return [ready, []];
 }
 const BunAdapter = require_adapter_index.createAdapter({
-	...require_adapter_web_standard_index.WebStandardAdapter,
 	name: "bun",
 	runtime: "bun",
+	isWebStandard: true,
+	parse: require_adapter_web_standard_index.WebStandardAdapter.parse,
+	response: require_adapter_web_standard_index.WebStandardAdapter.response,
 	listen(app, options, callback) {
 		const _config = app["~config"]?.serve;
-		const _options = typeof options === "object" ? options : { port: +options };
+		const optionsIsObject = typeof options === "object";
+		const _options = optionsIsObject ? { ...options } : {
+			port: +options,
+			fetch: (request, server) => app.fetch(request, server)
+		};
+		if (optionsIsObject) _options.fetch = (request, server) => app.fetch(request, server);
 		const serve = _config ? {
 			..._config,
 			..._options
 		} : _options;
-		const hasWs = app["~hasWS"];
-		serve.fetch = (request, server) => app.fetch(request, server);
-		app.server = Bun.serve(serve);
-		if (!hasWs) callback?.(app.server);
-		queueMicrotask(() => {
-			if (!app.pending) serve.fetch = app.fetch;
-			const buildWebSocket = () => {
-				const defaultConfig = app["~config"]?.websocket;
-				serve.websocket = defaultConfig ? Object.assign(require_ws_route.buildGlobalWSHandler(), defaultConfig) : require_ws_route.buildGlobalWSHandler();
-			};
-			if (hasWs) buildWebSocket();
-			const collectRoutes = () => {
-				const staticRoutes = collectStaticRoutes(app);
-				if (!staticRoutes) return;
-				if (staticRoutes[1].length) return Promise.all(staticRoutes[1]).then(() => {
-					serve.routes = staticRoutes[0];
-					app.server.reload(serve);
-				});
-				if (Object.keys(staticRoutes[0]).length) serve.routes = staticRoutes[0];
+		const onSetup = app["~ext"]?.setup;
+		const needsGate = app.pending || !!onSetup?.length;
+		let ready;
+		const build = () => {
+			const fetch = app.fetch;
+			let routes;
+			try {
+				routes = collectStaticRoutes(app);
+			} catch (error) {
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+			}
+			let websocket;
+			if (app["~hasWS"]) {
+				const resolved = require_generation.resolvedWsOf(app);
+				if (!resolved) throw new Error("[Elysia] internal: WebSocket routes are present but no capability provider was resolved.");
+				websocket = resolved.config ? Object.assign(resolved.provider.buildGlobalWSHandler(), resolved.config) : resolved.provider.buildGlobalWSHandler();
+			}
+			return {
+				fetch,
+				routes,
+				websocket
 			};
-			if (app.pending) {
-				if (app.server) app.server.reload(serve);
-				else app.server = Bun.serve(serve);
-				const reloadAfterModules = () => {
-					serve.fetch = app.fetch;
-					if (hasWs || app["~hasWS"]) buildWebSocket();
-					collectRoutes();
-					app.server.reload(serve);
-				};
-				app.modules.then(reloadAfterModules, reloadAfterModules);
-			} else {
-				collectRoutes();
-				if (app.server) app.server.reload(serve);
-				else app.server = Bun.serve(serve);
+		};
+		let built;
+		if (!needsGate) built = build();
+		if (needsGate) serve.fetch = (request, server) => ready.then(() => app.fetch(request, server));
+		else serve.fetch = withOrigin(built.fetch);
+		const server = app.server = Bun.serve(serve);
+		const reload = () => {
+			try {
+				server.reload(serve);
+			} catch (error) {
+				if (!serve.routes) throw error;
+				delete serve.routes;
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+				try {
+					server.reload(serve);
+				} catch (fallbackError) {
+					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+					throw fallbackError;
+				}
+			}
+		};
+		const setup = () => {
+			const onSetup = app["~ext"]?.setup;
+			if (!onSetup) return;
+			let pendingSetups;
+			for (let i = 0; i < onSetup.length; i++) {
+				const result = onSetup[i](app);
+				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
+			}
+			if (pendingSetups) return Promise.all(pendingSetups);
+		};
+		const rollback = (error) => {
+			if (app.server !== server) return;
+			try {
+				server.stop(true);
+			} catch (stopError) {
+				console.error(stopError);
+			} finally {
+				app.server = void 0;
 			}
-			require_memory.flushMemory();
-			if (hasWs) callback?.(app.server);
-		});
+			const cleanup = app["~ext"]?.cleanup;
+			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
+				const result = cleanup[i](app);
+				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
+			} catch (cleanupError) {
+				console.error(cleanupError);
+			}
+			return error;
+		};
+		const publish = () => {
+			if (app.server !== server) return;
+			built ??= build();
+			serve.fetch = withOrigin(built.fetch);
+			if (built.websocket) serve.websocket = built.websocket;
+			if (built.routes) serve.routes = built.routes[0];
+			if (needsGate || built.websocket || built.routes) reload();
+			if (callback) callback(server);
+		};
+		const start = () => {
+			if (app.server !== server) return;
+			const setupReady = setup();
+			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			publish();
+		};
+		try {
+			if (app.pending) ready = app.modules.then(start);
+			else {
+				const result = start();
+				if (result && typeof result.then === "function") ready = result;
+				else if (needsGate) ready = Promise.resolve();
+			}
+			ready?.catch(rollback);
+		} catch (error) {
+			rollback(error);
+			throw error;
+		}
 	}
 });
 

package/dist/adapter/bun/index.mjs

@@ -1,83 +1,222 @@
 import { createAdapter } from "../index.mjs";
-import { flattenChain, nullObject } from "../../utils.mjs";
+import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
+import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
-import { flushMemory } from "../../memory.mjs";
-import { buildGlobalWSHandler } from "../../ws/route.mjs";
+import { frozenRootOf, resolvedWsOf } from "../../generation.mjs";
+import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
+import { routeRow } from "../../route-table.mjs";
+import { origin } from "../origin.mjs";
 
 //#region src/adapter/bun/index.ts
+/**
+* ! This may looks like it would cause race condition, but it is not
+* Bun is single-threaded and synchronous, so the `finally` block will
+* always run before the next request comes in
+* @see ../origin.ts
+*
+* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
+* before its first suspension, that it holds the untouched original and may
+* defer materializing `request.signal`
+*
+* `finally` runs on the synchronous return of `fetch` (the returned promise is
+* not awaited), so the slot is live only for the handler's synchronous prologue.
+*/
+const withOrigin = (fetch) => (request, server) => {
+	origin.request = request;
+	try {
+		return fetch(request, server);
+	} finally {
+		origin.request = void 0;
+	}
+};
+const nativeStaticMethods = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS"
+]);
 function collectStaticRoutes(app) {
-	if (app["~ext"]?.hoc?.length) return;
-	const hook = flattenChain(app["~hookChain"]);
-	if (hook && (hook?.request?.length || hook?.mapResponse?.length || hook?.afterResponse?.length || hook?.trace?.length)) return;
+	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
-	const source = app["~staticResponse"];
-	if (!source) return;
+	const frozenRoot = frozenRootOf(app);
+	const fetchLevelHook = flattenChain(frozenRoot["~hookChain"]);
+	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
+	const length = table?.length ?? 0;
+	if (!table || !length) return;
+	const methods = table.method;
+	const paths = table.path;
+	const handlers = table.handler;
+	let hasCandidate = false;
+	for (let i = 0; i < length; i++) {
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		if (!nativeStaticMethods.has(methods[i])) continue;
+		hasCandidate = true;
+		break;
+	}
+	if (!hasCandidate) return;
 	const ready = nullObject();
-	const pending = [];
-	for (const rawPath in source) {
-		const path = encodeURI(rawPath);
-		const methods = source[rawPath];
-		for (const method in methods) {
-			const value = methods[method];
-			if (value instanceof Promise) pending.push(value.then((resolved) => {
-				if (resolved instanceof Response) (ready[path] ??= nullObject())[method] = resolved;
-			}, (err) => {
-				console.error(`[Elysia] Static route ${method} ${path} failed to resolve:`, err);
-			}));
-			else (ready[path] ??= nullObject())[method] = value;
+	const strictPath = frozenRoot["~config"]?.strictPath === true;
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
+	let explicitPaths;
+	if (!strictPath) {
+		explicitPaths = /* @__PURE__ */ new Map();
+		for (let i = 0; i < length; i++) {
+			const method = methods[i];
+			const path = paths[i];
+			let set = explicitPaths.get(method);
+			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
+			set.add(path);
+			if (needEncodeRegex.test(path)) {
+				const encoded = encodeURI(path);
+				if (encoded !== path) set.add(encoded);
+			}
 		}
 	}
-	return [ready, pending];
+	const add = (method, path, value) => {
+		if (needEncodeRegex.test(path)) path = encodeURI(path);
+		(ready[path] ??= nullObject())[method] = value;
+	};
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (method === "WS") continue;
+		const path = paths[i];
+		if (seen.get(method + " " + path) !== i) continue;
+		if (!nativeStaticMethods.has(method)) continue;
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		const value = buildNativeStaticResponse(routeRow(table, i), app);
+		if (!value) continue;
+		add(method, path, value);
+		if (!strictPath && !isDynamicRegex.test(path)) {
+			const loose = getLoosePath(path);
+			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
+		}
+	}
+	if (!Object.keys(ready).length) return;
+	return [ready, []];
 }
 const BunAdapter = createAdapter({
-	...WebStandardAdapter,
 	name: "bun",
 	runtime: "bun",
+	isWebStandard: true,
+	parse: WebStandardAdapter.parse,
+	response: WebStandardAdapter.response,
 	listen(app, options, callback) {
 		const _config = app["~config"]?.serve;
-		const _options = typeof options === "object" ? options : { port: +options };
+		const optionsIsObject = typeof options === "object";
+		const _options = optionsIsObject ? { ...options } : {
+			port: +options,
+			fetch: (request, server) => app.fetch(request, server)
+		};
+		if (optionsIsObject) _options.fetch = (request, server) => app.fetch(request, server);
 		const serve = _config ? {
 			..._config,
 			..._options
 		} : _options;
-		const hasWs = app["~hasWS"];
-		serve.fetch = (request, server) => app.fetch(request, server);
-		app.server = Bun.serve(serve);
-		if (!hasWs) callback?.(app.server);
-		queueMicrotask(() => {
-			if (!app.pending) serve.fetch = app.fetch;
-			const buildWebSocket = () => {
-				const defaultConfig = app["~config"]?.websocket;
-				serve.websocket = defaultConfig ? Object.assign(buildGlobalWSHandler(), defaultConfig) : buildGlobalWSHandler();
-			};
-			if (hasWs) buildWebSocket();
-			const collectRoutes = () => {
-				const staticRoutes = collectStaticRoutes(app);
-				if (!staticRoutes) return;
-				if (staticRoutes[1].length) return Promise.all(staticRoutes[1]).then(() => {
-					serve.routes = staticRoutes[0];
-					app.server.reload(serve);
-				});
-				if (Object.keys(staticRoutes[0]).length) serve.routes = staticRoutes[0];
+		const onSetup = app["~ext"]?.setup;
+		const needsGate = app.pending || !!onSetup?.length;
+		let ready;
+		const build = () => {
+			const fetch = app.fetch;
+			let routes;
+			try {
+				routes = collectStaticRoutes(app);
+			} catch (error) {
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+			}
+			let websocket;
+			if (app["~hasWS"]) {
+				const resolved = resolvedWsOf(app);
+				if (!resolved) throw new Error("[Elysia] internal: WebSocket routes are present but no capability provider was resolved.");
+				websocket = resolved.config ? Object.assign(resolved.provider.buildGlobalWSHandler(), resolved.config) : resolved.provider.buildGlobalWSHandler();
+			}
+			return {
+				fetch,
+				routes,
+				websocket
 			};
-			if (app.pending) {
-				if (app.server) app.server.reload(serve);
-				else app.server = Bun.serve(serve);
-				const reloadAfterModules = () => {
-					serve.fetch = app.fetch;
-					if (hasWs || app["~hasWS"]) buildWebSocket();
-					collectRoutes();
-					app.server.reload(serve);
-				};
-				app.modules.then(reloadAfterModules, reloadAfterModules);
-			} else {
-				collectRoutes();
-				if (app.server) app.server.reload(serve);
-				else app.server = Bun.serve(serve);
+		};
+		let built;
+		if (!needsGate) built = build();
+		if (needsGate) serve.fetch = (request, server) => ready.then(() => app.fetch(request, server));
+		else serve.fetch = withOrigin(built.fetch);
+		const server = app.server = Bun.serve(serve);
+		const reload = () => {
+			try {
+				server.reload(serve);
+			} catch (error) {
+				if (!serve.routes) throw error;
+				delete serve.routes;
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+				try {
+					server.reload(serve);
+				} catch (fallbackError) {
+					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+					throw fallbackError;
+				}
+			}
+		};
+		const setup = () => {
+			const onSetup = app["~ext"]?.setup;
+			if (!onSetup) return;
+			let pendingSetups;
+			for (let i = 0; i < onSetup.length; i++) {
+				const result = onSetup[i](app);
+				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
+			}
+			if (pendingSetups) return Promise.all(pendingSetups);
+		};
+		const rollback = (error) => {
+			if (app.server !== server) return;
+			try {
+				server.stop(true);
+			} catch (stopError) {
+				console.error(stopError);
+			} finally {
+				app.server = void 0;
 			}
-			flushMemory();
-			if (hasWs) callback?.(app.server);
-		});
+			const cleanup = app["~ext"]?.cleanup;
+			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
+				const result = cleanup[i](app);
+				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
+			} catch (cleanupError) {
+				console.error(cleanupError);
+			}
+			return error;
+		};
+		const publish = () => {
+			if (app.server !== server) return;
+			built ??= build();
+			serve.fetch = withOrigin(built.fetch);
+			if (built.websocket) serve.websocket = built.websocket;
+			if (built.routes) serve.routes = built.routes[0];
+			if (needsGate || built.websocket || built.routes) reload();
+			if (callback) callback(server);
+		};
+		const start = () => {
+			if (app.server !== server) return;
+			const setupReady = setup();
+			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			publish();
+		};
+		try {
+			if (app.pending) ready = app.modules.then(start);
+			else {
+				const result = start();
+				if (result && typeof result.then === "function") ready = result;
+				else if (needsGate) ready = Promise.resolve();
+			}
+			ready?.catch(rollback);
+		} catch (error) {
+			rollback(error);
+			throw error;
+		}
 	}
 });
 

package/dist/adapter/constants.d.ts

@@ -1,29 +1,6 @@
-import { ListenCallback, Serve } from "../universal/server.js";
-import { AnyLocalHook, MaybePromise } from "../types.js";
-import { Context } from "../context.js";
-import { AnyElysia } from "../base.js";
+import { ElysiaAdapterOptions } from "./types.js";
+
 //#region src/adapter/constants.d.ts
-declare const defaultAdapter: {
-  parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
-    json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
-    text: (context: Context) => MaybePromise<string>;
-    urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
-    arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
-    formData: (context: Context) => MaybePromise<Record<string, unknown>>;
-  };
-  name: string;
-  runtime: "node" | "deno" | "bun" | "cloudflare-worker" | "browser" | "vercel" | "netlify" | "lambda" | "fastly" | "edge" | "unknown" | (string & {});
-  isWebStandard: boolean;
-  listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
-  stop?(app: AnyElysia, closeActiveConnections?: boolean): Promise<void>;
-  response: {
-    map(response: unknown, set: Context["set"], ...params: unknown[]): unknown;
-    compact?(response: unknown, ...params: unknown[]): unknown;
-    static?(handle: unknown, hooks: AnyLocalHook, setHeaders?: Context["set"]["headers"], ...params: unknown[]): (() => unknown) | undefined;
-    nativeStatic?(handle: unknown, hooks: AnyLocalHook, set?: Context["set"]): (() => MaybePromise<Response>) | undefined;
-  };
-  fetch?(app: AnyElysia): (request: Request) => MaybePromise<Response>;
-};
+declare const defaultAdapter: ElysiaAdapterOptions;
 //#endregion
 export { defaultAdapter };