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

package/dist/adapter/bun/index.mjs

@@ -1,13 +1,56 @@
 import { createAdapter } from "../index.mjs";
-import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
-import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
+import { flattenChain, getLoosePath, isHTMLBundle, isSocketQuiet, nullObject, throwLifecycleErrors } from "../../utils.mjs";
+import { preloadTypebox } from "../../type/bridge.mjs";
+import { isProduction } from "../../universal/is-production.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
 import { frozenRootOf, resolvedWsOf } from "../../generation.mjs";
 import { origin } from "../origin.mjs";
 import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
-import { routeRow } from "../../route-table.mjs";
+import { RouteFlag, routeRow } from "../../route-table.mjs";
 
 //#region src/adapter/bun/index.ts
+function runLifecycle(epoch, callback, ...args) {
+	const invoking = epoch.invoking;
+	epoch.invoking = true;
+	try {
+		return callback(...args);
+	} finally {
+		epoch.invoking = invoking;
+	}
+}
+const unavailableFetch = () => new Response(null, {
+	headers: { connection: "close" },
+	status: 503
+});
+function releaseLifecycle(app, ext, createdExt, stop, registerCleanup) {
+	if (ext.stop === stop) delete ext.stop;
+	if (ext.cleanupEpoch === registerCleanup) delete ext.cleanupEpoch;
+	if (createdExt && app["~ext"] === ext && !Object.keys(ext).length) app["~ext"] = void 0;
+}
+async function waitForServerRequests(server, abandoned) {
+	while (server.pendingRequests && !abandoned()) await Bun.sleep(1);
+}
+async function settleServerWebSockets(lifecycle, errors) {
+	if (!lifecycle) return true;
+	lifecycle.closing = true;
+	let failed = false;
+	do {
+		for (const socket of lifecycle.sockets) if (socket.readyState < 3) try {
+			socket.terminate();
+		} catch (error) {
+			errors.push(error);
+			failed = true;
+		}
+		if (failed) return false;
+		await Bun.sleep(1);
+		const abandon = lifecycle.abandon === true;
+		for (const socket of lifecycle.sockets) if (abandon || isSocketQuiet(socket)) {
+			delete socket.data["~lifecycleRun"];
+			lifecycle.sockets.delete(socket);
+		}
+	} while (lifecycle.sockets.size);
+	return true;
+}
 /**
 * ! This may looks like it would cause race condition, but it is not
 * Bun is single-threaded and synchronous, so the `finally` block will
@@ -25,102 +68,186 @@ const withOrigin = (fetch) => (request, server) => {
 		origin.request = void 0;
 	}
 };
-const nativeStaticMethods = new Set([
-	"GET",
-	"POST",
-	"PUT",
-	"DELETE",
-	"PATCH",
-	"HEAD",
-	"OPTIONS"
-]);
+const isNativeStaticMethod = (method) => method === "GET" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "HEAD" || method === "OPTIONS";
+function expandOptional(path) {
+	const at = path.indexOf("?");
+	if (at === -1) return [path];
+	const start = path.lastIndexOf("/", at);
+	const rest = path.slice(at + 1);
+	return [...expandOptional(path.slice(0, start) + rest), ...expandOptional(path.slice(0, at) + rest)].map((variant) => variant || "/");
+}
+function isNativePath(path) {
+	const names = /* @__PURE__ */ new Set();
+	const segments = path.split("/");
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (segment.indexOf("*") !== -1) {
+			if (segment !== "*" || i !== segments.length - 1) return false;
+		} else if (segment.indexOf(":") !== -1) {
+			if (!/^:[A-Za-z_$][\w$]*$/.test(segment)) return false;
+			if (names.has(segment)) return false;
+			names.add(segment);
+		}
+	}
+	return true;
+}
+/**
+* HTML bundles served by Bun's native router.
+*
+* A `:param` / `*` bundle (SPA fallback) matches before `fetch`, so with a
+* `handoff` every other route of that method is registered natively too,
+* handing off to `fetch`: Bun's specificity (exact > param > wildcard) then
+* picks the Elysia route, and only unmatched paths reach the bundle (Elysia's
+* own router leaves these bundles out, see `#buildRouterUnsafe`).
+*
+* All or nothing: when any route cannot be expressed in Bun's router, dynamic
+* bundles are not served natively at all, since that route would be shadowed.
+*/
+function collectHTMLBundleRoutes(app, handoff, routes) {
+	let dynamic;
+	let bundles;
+	for (const route of app["~routes"]) {
+		const [method, path, handler] = route;
+		if (!isNativeStaticMethod(method) || !isHTMLBundle(handler)) continue;
+		if (path.indexOf(":") !== -1 || path.indexOf("*") !== -1) {
+			if (!handoff) continue;
+			(dynamic ??= /* @__PURE__ */ new Set()).add(method);
+			(bundles ??= []).push([
+				method,
+				path,
+				handler
+			]);
+		} else ((routes ??= nullObject())[path] ??= nullObject())[method] = handler;
+		if (!isProduction() && (route[4] || route[5] || route[6])) console.warn(`[Elysia] ${method} ${path} is an HTML bundle served natively, hooks do not run for it`);
+	}
+	if (!dynamic) return routes;
+	const strictPath = app["~config"]?.strictPath === true;
+	const handoffs = [];
+	for (const [method, path, handler] of app["~routes"]) {
+		if (isHTMLBundle(handler)) continue;
+		const targets = method === "*" ? dynamic : dynamic.has(method) ? [method] : void 0;
+		if (!targets) continue;
+		for (const variant of expandOptional(path)) {
+			const loose = strictPath || variant.endsWith("*") ? variant : getLoosePath(variant);
+			for (const raw of loose === variant ? [variant] : [variant, loose]) {
+				if (!isNativePath(raw)) {
+					if (!isProduction()) console.warn(`[Elysia] ${method} ${path} cannot be expressed in Bun's router, so :param / * HTML bundles are not served natively (they would shadow it)`);
+					return routes;
+				}
+				const encoded = encodeURI(raw);
+				for (const target of targets) {
+					if (!/[^ -~]/.test(raw)) handoffs.push([raw, target]);
+					if (encoded !== raw) handoffs.push([encoded, target]);
+				}
+			}
+		}
+	}
+	for (const [method, path, bundle] of bundles) ((routes ??= nullObject())[path] ??= nullObject())[method] = bundle;
+	for (const [key, method] of handoffs) (routes[key] ??= nullObject())[method] ??= handoff;
+	return routes;
+}
 function collectStaticRoutes(app) {
-	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
 	const frozenRoot = frozenRootOf(app);
 	const fetchLevelHook = flattenChain(frozenRoot["~hookChain"]);
-	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const promoteResponses = app["~config"]?.nativeStaticResponse !== false && !fetchLevelHook?.request?.length && !fetchLevelHook?.trace?.length && !frozenRoot["~ext"]?.hoc?.length;
 	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;
+	const { method: methods, path: paths, handler: handlers, flags } = table;
+	const isStatic = (i) => isNativeStaticMethod(methods[i]) && (flags[i] & RouteFlag.Dynamic) === 0;
+	const isPromotable = (h) => promoteResponses && typeof h !== "function" && !(h instanceof Error) && !(h instanceof Promise);
 	let hasCandidate = false;
 	for (let i = 0; i < length; i++) {
+		if (!isStatic(i)) continue;
 		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 (isHTMLBundle(h) || isPromotable(h)) {
+			hasCandidate = true;
+			break;
+		}
 	}
 	if (!hasCandidate) return;
-	const ready = nullObject();
 	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);
-			}
+	const routeIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < length; i++) {
+		if (!isStatic(i)) continue;
+		const method = methods[i];
+		const path = paths[i];
+		let pathsByMethod = routeIndex.get(method);
+		if (!pathsByMethod) routeIndex.set(method, pathsByMethod = /* @__PURE__ */ new Map());
+		pathsByMethod.set(path, i);
+		if (!strictPath && (flags[i] & RouteFlag.Encode) !== 0) {
+			const encoded = encodeURI(path);
+			if (encoded !== path && !pathsByMethod.has(encoded)) pathsByMethod.set(encoded, -1);
 		}
 	}
-	const add = (method, path, value) => {
-		if (needEncodeRegex.test(path)) path = encodeURI(path);
+	const ready = nullObject();
+	let hasReady = false;
+	const add = (method, path, value, needsEncode) => {
+		if (needsEncode) path = encodeURI(path);
 		(ready[path] ??= nullObject())[method] = value;
+		hasReady = true;
 	};
 	for (let i = 0; i < length; i++) {
+		if (!isStatic(i)) continue;
 		const method = methods[i];
-		if (method === "WS") continue;
+		const pathsByMethod = routeIndex.get(method);
 		const path = paths[i];
-		if (seen.get(method + " " + path) !== i) continue;
-		if (!nativeStaticMethods.has(method)) continue;
+		if (pathsByMethod.get(path) !== i) continue;
 		const h = handlers[i];
-		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
-		const value = buildNativeStaticResponse(routeRow(table, i), app);
+		let value;
+		if (isHTMLBundle(h)) value = h;
+		else if (!isPromotable(h)) continue;
+		else value = buildNativeStaticResponse(routeRow(table, i), app);
 		if (!value) continue;
-		add(method, path, value);
-		if (!strictPath && !isDynamicRegex.test(path)) {
+		const needsEncode = (flags[i] & RouteFlag.Encode) !== 0;
+		add(method, path, value, needsEncode);
+		if (!strictPath) {
 			const loose = getLoosePath(path);
-			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
+			if (loose !== path && !pathsByMethod.has(loose)) add(method, loose, value, needsEncode);
 		}
 	}
-	if (!Object.keys(ready).length) return;
-	return [ready, []];
+	if (!hasReady) return;
+	return ready;
 }
 const BunAdapter = createAdapter({
-	name: "bun",
-	runtime: "bun",
-	isWebStandard: true,
 	parse: WebStandardAdapter.parse,
 	response: WebStandardAdapter.response,
 	listen(app, options, callback) {
-		const _config = app["~config"]?.serve;
-		const optionsIsObject = typeof options === "object";
-		let live;
-		const gatedFetch = (request, server) => live ? live(request, server) : Promise.resolve(ready).then(() => {
-			if (!live) throw new Error("[Elysia] Server was stopped before it was ready");
-			return live(request, server);
-		});
-		const _options = optionsIsObject ? { ...options } : {
+		if (app.server || app["~ext"]?.stop) throw new Error("[Elysia] Cannot call listen() while a server or teardown is active");
+		const requestReady = Promise.withResolvers();
+		function gatedFetch(request, server) {
+			return live && !cancelled ? live(request, server) : requestReady.promise.then(() => {
+				if (cancelled || !live) return unavailableFetch();
+				return live(request, server);
+			});
+		}
+		const _options = typeof options === "object" ? {
+			...options,
+			fetch: gatedFetch
+		} : {
 			port: +options,
 			fetch: gatedFetch
 		};
-		if (optionsIsObject) _options.fetch = gatedFetch;
+		const _config = app["~config"]?.serve;
 		const serve = _config ? {
 			..._config,
 			..._options
 		} : _options;
-		let ready;
+		const handoff = (request, server) => serve.fetch(request, server);
+		const htmlRoutes = collectHTMLBundleRoutes(app, app.pending ? void 0 : handoff);
+		const server = app.server = Bun.serve(serve.routes || serve.error || htmlRoutes ? {
+			...serve,
+			error: unavailableFetch,
+			routes: htmlRoutes ?? {}
+		} : serve);
+		let live;
+		let cancelled = false;
+		let shutdownAttempt;
+		let wsLifecycle;
+		let modulesReady;
+		let pendingSetups;
+		let setupsSettled;
 		const build = () => {
 			const fetch = app.fetch;
 			let routes;
@@ -129,11 +256,22 @@ const BunAdapter = createAdapter({
 			} catch (error) {
 				console.warn("[Elysia] Native static promotion was skipped:", error);
 			}
+			routes = collectHTMLBundleRoutes(app, handoff, routes);
 			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();
+				const handler = resolved.provider.buildGlobalWSHandler();
+				websocket = resolved.config ? Object.assign(handler, resolved.config) : handler;
+				const setter = Object.getOwnPropertyDescriptor(handler, "~lifecycle")?.set;
+				if (setter) {
+					wsLifecycle = {
+						closing: false,
+						sockets: /* @__PURE__ */ new Set(),
+						run: runLifecycle.bind(null, epoch)
+					};
+					setter.call(handler, wsLifecycle);
+				}
 			}
 			return {
 				fetch,
@@ -141,79 +279,296 @@ const BunAdapter = createAdapter({
 				websocket
 			};
 		};
-		let built;
-		const server = app.server = Bun.serve(serve);
-		const reload = () => {
+		let startupFailure;
+		let forceRequested = false;
+		const force = Promise.withResolvers();
+		const abandon = Promise.withResolvers();
+		let forceDone = false;
+		let nativeStopped = false;
+		let abandoned = false;
+		let published = false;
+		let cleanupCompleted = false;
+		let idleRequired = false;
+		let cleanupFailures;
+		let observedOutcome;
+		let persistentCleanup;
+		let persistentCleanupLength = -1;
+		const epochCleanup = [];
+		const createdExt = app["~ext"] === void 0;
+		const ext = app["~ext"] ??= nullObject();
+		const epoch = {
+			setup: false,
+			invoking: false
+		};
+		const snapshotCleanup = () => {
+			if (persistentCleanupLength !== -1) return;
+			persistentCleanup = ext.cleanup;
+			persistentCleanupLength = persistentCleanup?.length ?? 0;
+		};
+		const registerCleanup = (handler) => {
+			if (ext.cleanupEpoch !== registerCleanup) return false;
+			if (!epoch.setup) throw new Error("[Elysia] .cleanup() called after its setup epoch settled");
+			if (Array.isArray(handler)) epochCleanup.push(...handler);
+			else epochCleanup.push(handler);
+			return true;
+		};
+		const gate = () => {
+			if (!published) return;
+			live = void 0;
+			if (wsLifecycle) wsLifecycle.closing = true;
 			try {
-				server.reload(serve);
+				server.reload({
+					...serve,
+					fetch: unavailableFetch,
+					error: unavailableFetch,
+					routes: {}
+				});
 			} 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;
+				return { error };
+			}
+		};
+		const nativeStop = async (closeActiveConnections, errors) => {
+			try {
+				const stopping = server.stop(closeActiveConnections);
+				await (closeActiveConnections ? stopping : Promise.race([stopping, force.promise]));
+				if (!closeActiveConnections && forceRequested && !forceDone) return false;
+				nativeStopped = true;
+				if (closeActiveConnections) {
+					forceDone = true;
+					forceRequested = false;
+				}
+				return true;
+			} catch (error) {
+				if (closeActiveConnections) forceRequested = true;
+				errors.push(error);
+				return false;
+			}
+		};
+		const isAbandoned = () => abandoned;
+		const quiesce = async (force) => {
+			const errors = [];
+			if (!published) return {
+				errors,
+				releasable: await nativeStop(true, errors),
+				safe: true
+			};
+			if (force && !idleRequired && !wsLifecycle?.closing) {
+				const stopped = await nativeStop(true, errors);
+				return {
+					errors,
+					releasable: stopped,
+					safe: stopped
+				};
+			}
+			const gateFailure = gate();
+			if (gateFailure) errors.push(gateFailure.error);
+			let socketsSettled = await settleServerWebSockets(wsLifecycle, errors);
+			await Promise.resolve();
+			let close = forceRequested || gateFailure !== void 0 || !socketsSettled;
+			if (!close && nativeStopped) await waitForServerRequests(server, isAbandoned);
+			idleRequired = true;
+			let stopped = true;
+			while (!nativeStopped || forceRequested && !forceDone) {
+				if (nativeStopped) close = true;
+				stopped = await nativeStop(close, errors);
+				if (stopped) {
+					if (socketsSettled) socketsSettled = await settleServerWebSockets(wsLifecycle, errors);
+					continue;
+				}
+				if (close) break;
+				await waitForServerRequests(server, isAbandoned);
+				close = true;
+			}
+			let idleClosed = true;
+			if (idleRequired) {
+				const closeIdle = server.closeIdleConnections;
+				if (closeIdle) try {
+					closeIdle.call(server);
+				} catch (error) {
+					errors.push(error);
+					idleClosed = false;
 				}
+				if (idleClosed && !gateFailure) idleRequired = false;
 			}
+			const safe = socketsSettled && stopped && idleClosed && (!gateFailure || forceDone);
+			return {
+				errors,
+				releasable: safe,
+				safe
+			};
 		};
 		const setup = () => {
-			const onSetup = app["~ext"]?.setup;
+			snapshotCleanup();
+			const onSetup = ext.setup;
 			if (!onSetup) return;
-			let pendingSetups;
+			epoch.setup = true;
+			ext.cleanupEpoch = registerCleanup;
 			for (let i = 0; i < onSetup.length; i++) {
-				const result = onSetup[i](app);
-				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
+				if (cancelled) break;
+				try {
+					const result = runLifecycle(epoch, onSetup[i], app);
+					if (result && typeof result.then === "function") (pendingSetups ??= []).push(Promise.resolve(result));
+				} catch (error) {
+					if (!pendingSetups) epoch.setup = false;
+					stop(true, { error }).catch(() => {});
+					throw error;
+				}
 			}
-			if (pendingSetups) return Promise.all(pendingSetups);
+			if (pendingSetups) {
+				setupsSettled = Promise.allSettled(pendingSetups);
+				return Promise.all(pendingSetups).then(() => epoch.setup = false);
+			}
+			epoch.setup = false;
 		};
-		const rollback = (error) => {
-			if (app.server !== server) return;
-			try {
-				server.stop(true);
-			} catch (stopError) {
-				console.error(stopError);
-			} finally {
-				app.server = void 0;
-			}
-			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 stop = (closeActiveConnections, failure) => {
+			const reentrant = epoch.invoking;
+			if (failure) startupFailure ??= failure;
+			if (closeActiveConnections === true) {
+				force.resolve();
+				if (!failure) abandon.resolve();
+				if (!forceDone) forceRequested = true;
+			}
+			cancelled = true;
+			requestReady.resolve();
+			if (app.server === server) app.server = void 0;
+			let outcome;
+			if (shutdownAttempt) {
+				if (closeActiveConnections === true && !forceDone) {
+					abandoned = true;
+					if (wsLifecycle) wsLifecycle.abandon = true;
+				}
+				outcome = shutdownAttempt;
+			} else {
+				const { promise, resolve, reject } = Promise.withResolvers();
+				outcome = shutdownAttempt = promise;
+				const quiescence = quiesce(forceRequested || !published);
+				let releasable = false;
+				let abandonedSetups;
+				(async () => {
+					try {
+						await Promise.resolve();
+						if (modulesReady) try {
+							await Promise.race([modulesReady, force.promise]);
+						} catch (error) {
+							startupFailure ??= { error };
+						}
+						if (setupsSettled) {
+							const setupResults = await Promise.race([setupsSettled, abandon.promise]);
+							if (!setupResults) abandonedSetups = setupsSettled;
+							else if (!startupFailure) for (let i = 0; i < setupResults.length; i++) {
+								const result = setupResults[i];
+								if (result.status === "rejected") {
+									startupFailure = { error: result.reason };
+									break;
+								}
+							}
+						}
+						epoch.setup = false;
+						const errors = [];
+						const quiesced = await quiescence;
+						if (startupFailure) errors.push(startupFailure.error);
+						errors.push(...quiesced.errors);
+						releasable = quiesced.releasable;
+						if (!quiesced.safe) {
+							if (cleanupFailures) errors.push(...cleanupFailures);
+							throwLifecycleErrors(errors);
+						}
+						if (!cleanupCompleted) {
+							snapshotCleanup();
+							if (ext.stop === stop) {
+								const length = persistentCleanupLength + epochCleanup.length;
+								for (let n = 0; n < length; n++) {
+									if (ext.stop !== stop) break;
+									const i = startupFailure ? length - 1 - n : n;
+									const handler = i < persistentCleanupLength ? persistentCleanup[i] : epochCleanup[i - persistentCleanupLength];
+									try {
+										await runLifecycle(epoch, handler, app);
+									} catch (error) {
+										(cleanupFailures ??= []).push(error);
+									}
+								}
+							}
+							cleanupCompleted = true;
+							epochCleanup.length = 0;
+						}
+						if (cleanupFailures) errors.push(...cleanupFailures);
+						const release = () => releaseLifecycle(app, ext, createdExt, stop, registerCleanup);
+						if (releasable && abandonedSetups) abandonedSetups.then((results) => {
+							for (const result of results) if (result.status === "rejected") console.error("[Elysia] setup abandoned by stop(true) failed:", result.reason);
+							release();
+						});
+						else if (releasable) release();
+						throwLifecycleErrors(errors);
+					} finally {
+						epoch.setup = false;
+						if (!releasable) shutdownAttempt = void 0;
+					}
+				})().then(resolve, reject);
+			}
+			if (!reentrant) return outcome;
+			if (observedOutcome !== outcome) {
+				observedOutcome = outcome;
+				outcome.catch((error) => {
+					console.error("[Elysia] stop() failed:", error);
+				});
+			}
+			return Promise.resolve();
 		};
+		ext.stop = stop;
 		const publish = () => {
-			if (app.server !== server) return;
-			built ??= build();
-			live = serve.fetch = withOrigin(built.fetch);
-			if (built.websocket) serve.websocket = built.websocket;
-			if (built.routes) serve.routes = built.routes[0];
-			reload();
-			if (callback) callback(server);
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
+			try {
+				const built = build();
+				live = serve.fetch = withOrigin(built.fetch);
+				published = true;
+				if (built.websocket) serve.websocket = built.websocket;
+				if (built.routes) serve.routes = built.routes;
+				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;
+					}
+				}
+				if (callback) callback(server);
+			} catch (error) {
+				startupFailure ??= { error };
+				throw error;
+			}
+			requestReady.resolve();
 		};
 		const start = () => {
-			if (app.server !== server) return;
+			modulesReady = void 0;
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
 			const setupReady = setup();
-			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			if (setupReady) return setupReady.then(publish);
 			publish();
 		};
 		try {
-			if (app.pending) ready = app.modules.then(start);
-			else ready = Promise.resolve().then(start);
-			ready.catch((error) => {
+			const modules = modulesReady = app.modules;
+			const preload = preloadTypebox();
+			(preload ? Promise.all([modules, preload]) : modules).then(start).catch((error) => stop(true, { error })).catch((error) => {
 				console.error("[Elysia] listen() failed:", error);
-				return rollback(error);
+				if (typeof process !== "undefined") process.exitCode = 1;
 			});
 		} catch (error) {
-			rollback(error);
+			stop(true, { error }).catch(console.error);
 			throw error;
 		}
 	}
 });
 
 //#endregion
-export { BunAdapter, collectStaticRoutes };
+export { BunAdapter, collectHTMLBundleRoutes, collectStaticRoutes, isHTMLBundle };