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

package/dist/ws/route.js

@@ -2,13 +2,18 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../universal/constants.js');
 const require_utils = require('../utils.js');
 const require_type_bridge = require('../type/bridge.js');
-const require_universal_is_production = require('../universal/is-production.js');
 const require_error = require('../error.js');
+const require_cookie_crypto = require('../cookie/crypto.js');
 const require_adapter_web_standard_handler = require('../adapter/web-standard/handler.js');
 const require_parse_query = require('../parse-query.js');
+const require_compile_aot = require('../compile/aot.js');
 const require_generation = require('../generation.js');
+const require_cookie_config = require('../cookie/config.js');
+const require_cookie_utils = require('../cookie/utils.js');
+const require_handler_utils = require('../handler/utils.js');
 const require_handler_error = require('../handler/error.js');
 const require_compile_handler_utils = require('../compile/handler/utils.js');
+const require_sucrose = require('../sucrose.js');
 const require_validator_index = require('../validator/index.js');
 const require_validator_route = require('../validator/route.js');
 const require_compile_handler_frozen_validator = require('../compile/handler/frozen-validator.js');
@@ -18,72 +23,6 @@ const require_ws_parser = require('./parser.js');
 
 //#region src/ws/route.ts
 const EMPTY_HOOKS = Object.freeze([]);
-/**
-* Build-time (route-registration-time) analysis of a WS `message` handler to
-* decide whether the per-frame `ws.body` view must be assigned.
-*/
-function handlerMayTouchBody(fn) {
-	if (!fn) return false;
-	let source;
-	try {
-		source = Function.prototype.toString.call(fn);
-	} catch {
-		return true;
-	}
-	if (source.indexOf("[native code]") !== -1) return true;
-	if (/\bbody\b/.test(source)) return true;
-	if (/\barguments\b/.test(source)) return true;
-	if (source.indexOf("[") !== -1) return true;
-	if (source.indexOf("...") !== -1) return true;
-	const parsed = firstParamIdentifier(source);
-	if (parsed === void 0) return true;
-	const { name: wsName, bodyStart, paramsEnd } = parsed;
-	if (source.slice(0, paramsEnd).indexOf("(", 1) !== -1) return true;
-	const body = source.slice(bodyStart);
-	const safeName = wsName.replace(/[$]/g, "\\$&");
-	if (new RegExp(`(?<![\\w$.])${safeName}(?![\\w$]|\\s*\\.)`).test(body)) return true;
-	return false;
-}
-function firstParamIdentifier(source) {
-	const open = source.indexOf("(");
-	if (open === -1) {
-		const m = /^\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(source);
-		if (!m) return void 0;
-		const end = m.index + m[0].length;
-		return {
-			name: m[1],
-			bodyStart: end,
-			paramsEnd: end
-		};
-	}
-	let depth = 0;
-	let close = -1;
-	for (let i = open; i < source.length; i++) {
-		const c = source[i];
-		if (c === "(") depth++;
-		else if (c === ")") {
-			depth--;
-			if (depth === 0) {
-				close = i;
-				break;
-			}
-		}
-	}
-	if (close === -1) return void 0;
-	const params = source.slice(open + 1, close).trim();
-	if (params.length === 0) return void 0;
-	let first = params;
-	const comma = params.indexOf(",");
-	if (comma !== -1) first = params.slice(0, comma).trim();
-	if (first[0] === "{" || first[0] === "[") return void 0;
-	const m = /^([A-Za-z_$][\w$]*)/.exec(first);
-	if (!m) return void 0;
-	return {
-		name: m[1],
-		bodyStart: close + 1,
-		paramsEnd: close + 1
-	};
-}
 function concatHooks(...sources) {
 	let result;
 	for (let i = 0; i < sources.length; i++) {
@@ -104,7 +43,6 @@ async function applyMapResponse(ws, value, mapResponses) {
 	}
 	return value;
 }
-const isBackpressured = (status) => typeof status === "number" && status <= 0;
 const isEmptyPayload = (payload) => {
 	if (payload === "" || payload == null) return true;
 	if (typeof payload === "string") return false;
@@ -136,7 +74,7 @@ async function handleWSResponse(ws, value, mapResponses) {
 				const mapped = mapResponses.length ? await applyMapResponse(ws, yielded, mapResponses) : yielded;
 				let status = ws.send(mapped);
 				const canBackpressure = !isEmptyPayload(mapped);
-				while (canBackpressure && isBackpressured(status)) {
+				while (canBackpressure && typeof status === "number" && status <= 0) {
 					if (ws.readyState >= 2) return;
 					await waitForDrain(ws);
 					if (ws.readyState >= 2) return;
@@ -155,6 +93,38 @@ async function handleWSResponse(ws, value, mapResponses) {
 	const mapped = mapResponses.length ? await applyMapResponse(ws, value, mapResponses) : value;
 	ws.send(mapped);
 }
+function wsErrorFrameFallback(error) {
+	if (require_handler_error.claimsProblemType(error)) try {
+		const status = require_handler_error.resolveStatus(error.status);
+		const served = typeof status === "number" && status >= 100 ? status : 500;
+		const stringify = (value) => typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+		const problemFrame = (detail) => JSON.stringify(require_error.problemBody({
+			type: error.type ?? "about:blank",
+			...typeof error.code === "string" ? { code: error.code } : {},
+			detail,
+			status: served
+		}));
+		const serveMessage = () => problemFrame(require_handler_error.statusFallbackBody(error, served));
+		const serveDetail = () => {
+			const detail = require_handler_error.readAnnotation(error, "detail", true);
+			if (detail === void 0) return serveMessage();
+			if (detail instanceof Promise) return detail.then((resolved) => resolved === void 0 ? serveMessage() : problemFrame(resolved)).catch(() => wsLegacyFrame(error));
+			return problemFrame(detail);
+		};
+		const value = require_handler_error.readAnnotation(error, "value", true);
+		if (value === void 0) return serveDetail();
+		if (value instanceof Promise) return value.then((resolved) => resolved === void 0 ? serveDetail() : stringify(resolved)).catch(() => wsLegacyFrame(error));
+		return stringify(value);
+	} catch {}
+	return wsLegacyFrame(error);
+}
+function wsLegacyFrame(error) {
+	if (error?.status) {
+		const body = require_handler_error.statusFallbackBody(error, error.status);
+		return typeof body === "object" ? JSON.stringify(body) : String(body);
+	}
+	return require_error.internalServerErrorBodyString(error);
+}
 function wsErrorFrame(error) {
 	if (error instanceof require_error.ValidationError) try {
 		return JSON.stringify(error.payload);
@@ -167,12 +137,7 @@ function wsErrorFrame(error) {
 	} catch {}
 	if (typeof error?.toResponse === "function") {
 		if (error instanceof require_error.ElysiaError && error.toResponse === require_error.ElysiaError.prototype.toResponse) try {
-			return JSON.stringify(require_error.problemBody({
-				type: error.problemType,
-				title: error.problemTitle,
-				status: error.status ?? 500,
-				detail: error.response !== void 0 && error.response !== error.problemTitle ? error.response : void 0
-			}));
+			return JSON.stringify(require_error.problemBody(require_error.elysiaErrorProblem(error)));
 		} catch {}
 		try {
 			const r = error.toResponse();
@@ -181,13 +146,6 @@ function wsErrorFrame(error) {
 	}
 	return wsErrorFrameFallback(error);
 }
-function wsErrorFrameFallback(error) {
-	if (error?.status) {
-		const body = error.response !== void 0 ? error.response : require_universal_is_production.isProduction() ? error.status >= 500 ? "Internal Server Error" : "" : error.message ?? "";
-		return typeof body === "object" ? JSON.stringify(body) : String(body);
-	}
-	return require_error.internalServerErrorBodyString(error);
-}
 function sendErrorFrame(ws, error) {
 	const frame = wsErrorFrame(error);
 	if (typeof frame === "string") {
@@ -203,9 +161,7 @@ function sendErrorFrame(ws, error) {
 	}, () => {});
 }
 function validateUpgradeChannel(validator, value, type) {
-	if (validator instanceof require_validator_index.StandardValidator) return validator.From(value, type);
-	if (validator.hasCodec) return validator.From(value, type);
-	return validator.EncodeFrom(value, type);
+	return validator.hasCodec || validator instanceof require_validator_index.StandardValidator ? validator.From(value, type) : validator.EncodeFrom(value, type);
 }
 const wsOptions = [
 	"maxPayloadLength",
@@ -218,14 +174,35 @@ const wsOptions = [
 ];
 function buildWSRoute(route, app) {
 	const hook = require_compile_handler_index.resolveWSLocalHook(require_compile_handler_index.localMacroRoot(route[7] ?? route[3] ?? app, app), route[4], app) ?? require_utils.nullObject();
+	const instance = route[3] ?? app;
+	const appHookChain = route[5];
+	const inheritedChain = route[6];
+	const composed = require_compile_handler_index.composeRouteHook(instance, route[4], appHookChain, inheritedChain, app, route[7]) ?? hook;
 	let validators;
-	const frozenEager = require_type_bridge.isBridgeLive() ? void 0 : require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, app, "WS", route[1]);
+	const programId = require_generation.frozenRootOf(app)["~programId"];
+	const captured = require_compile_aot.Compiled.getHandler(programId, "WS", route[1]);
+	let live = false;
+	if (require_compile_aot.Capture.isCapturing()) require_compile_aot.Capture.handler({
+		method: "WS",
+		path: route[1],
+		alias: "",
+		code: "",
+		k: require_compile_handler_index.routeShape(composed, void 0, app)
+	});
+	else if (require_compile_aot.Compiled.hasProgram(programId)) {
+		const shape = require_compile_handler_index.routeShape(composed, void 0, app);
+		live = shape === void 0 || captured?.k !== shape;
+	}
+	const frozenEager = require_type_bridge.isBridgeLive() || live ? void 0 : require_compile_handler_frozen_validator.buildFrozenRouteValidator(composed, app, "WS", route[1]);
 	if (frozenEager) validators = frozenEager;
 	else try {
-		validators = new require_validator_route.RouteValidator(hook, {
+		validators = new require_validator_route.RouteValidator(composed, {
 			models: require_generation.frozenRootOf(app)["~ext"]?.models,
 			app,
-			aot: {
+			normalize: require_generation.frozenRootOf(app)["~config"]?.normalize,
+			sanitize: require_generation.frozenRootOf(app)["~config"]?.sanitize,
+			schemas: composed.schemas,
+			aot: live ? void 0 : {
 				method: "WS",
 				path: route[1]
 			},
@@ -233,23 +210,23 @@ function buildWSRoute(route, app) {
 		});
 	} catch (error) {
 		if (!require_compile_handler_frozen_validator.isBridgeNotInitialized(error)) throw error;
-		const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, app, "WS", route[1]);
+		if (live) throw new Error(require_compile_aot.aotDrift("WS", route[1]), { cause: error });
+		const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(composed, app, "WS", route[1]);
 		if (!frozen) throw error;
 		validators = frozen;
 	}
+	if (live && captured) require_compile_aot.warnAotDrift("WS", route[1]);
 	const responseValidator = validators.response;
 	const defaultResponseValidator = responseValidator ? responseValidator[200] ?? responseValidator[Object.keys(responseValidator)[0]] : void 0;
+	const cookieIsOptional = !!composed.cookie?.["~optional"];
 	const queryChannels = require_compile_handler_utils.getQueryParseChannels(validators.query?.schema);
 	const queryArray = queryChannels?.array;
 	const queryObject = queryChannels?.object;
-	const instance = route[3] ?? app;
-	const appHookChain = route[5];
-	const inheritedChain = route[6];
-	const flatAppHook = require_compile_handler_index.composeRouteHook(instance, void 0, appHookChain, inheritedChain, app, route[7]) ?? {};
-	const parseHooks = hook.parse == null ? [] : Array.isArray(hook.parse) ? hook.parse : [hook.parse];
+	const flatAppHook = require_compile_handler_index.composeRouteHook(instance, void 0, appHookChain, inheritedChain, app, route[7], false) ?? {};
+	const parseHooks = concatHooks(hook.parse);
 	const transforms = concatHooks(flatAppHook.transform, hook.transform);
 	const allBeforeHandles = concatHooks(flatAppHook.beforeHandle, hook.beforeHandle);
-	const deriveEntries = [...flatAppHook["~deriveEntries"] ?? [], ...hook["~deriveEntries"] ?? []];
+	const deriveEntries = concatHooks(flatAppHook["~deriveEntries"], hook["~deriveEntries"]);
 	const deriveSet = deriveEntries.length ? new Set(deriveEntries.map(require_utils.deriveEntryFn)) : void 0;
 	const upgradeDeriveModes = require_compile_handler_utils.deriveModes(allBeforeHandles, deriveEntries);
 	const messageBeforeHandles = allBeforeHandles.filter((fn) => !deriveSet?.has(fn));
@@ -257,8 +234,31 @@ function buildWSRoute(route, app) {
 	const mapResponses = concatHooks(flatAppHook.mapResponse, hook.mapResponse);
 	const afterResponses = concatHooks(flatAppHook.afterResponse, hook.afterResponse);
 	const errorHandlers = concatHooks(hook.error, flatAppHook.error);
+	const inference = require_sucrose.sucrose(hook.message, {
+		beforeHandle: [
+			...allBeforeHandles,
+			hook.open,
+			hook.close,
+			hook.drain,
+			hook.ping,
+			hook.pong,
+			typeof hook.upgrade === "function" ? hook.upgrade : void 0
+		].filter(Boolean),
+		parse: parseHooks,
+		transform: transforms,
+		error: errorHandlers,
+		afterHandle: afterHandles,
+		mapResponse: mapResponses,
+		afterResponse: afterResponses
+	});
+	const cookieConfig = validators.cookie || inference.cookie ? require_cookie_config.compileCookieConfig(composed.cookie, require_generation.frozenRootOf(app)["~config"]?.cookie, require_generation.frozenRootOf(app)["~ext"]?.models, composed.schemas) : void 0;
+	const signCookies = cookieConfig?.hasSign ? (set) => require_cookie_utils.signCookieValues(set.cookie, cookieConfig) : void 0;
 	const parseMessage = require_ws_parser.createMessageParser(parseHooks);
-	const handleUpgradeError = require_handler_error.createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => require_adapter_web_standard_handler.mapResponse(response, set, context?.request)), void 0, require_generation.frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
+	const handleUpgradeError = require_handler_error.createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => {
+		const map = () => require_adapter_web_standard_handler.mapResponse(response, set, context?.request);
+		const pending = signCookies?.(set);
+		return pending ? pending.then(map) : map();
+	}), require_generation.frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
 	async function handleError(ws, error) {
 		const errCtx = Object.create(ws);
 		errCtx.error = error;
@@ -272,6 +272,7 @@ function buildWSRoute(route, app) {
 				break;
 			}
 			if (r !== void 0) {
+				r = require_handler_error.adoptErrorType(r, error);
 				try {
 					await handleWSResponse(ws, r, mapResponses);
 				} catch {}
@@ -281,12 +282,6 @@ function buildWSRoute(route, app) {
 		sendErrorFrame(ws, error);
 	}
 	const bodyValidator = validators.body;
-	function validateMessageBody(message) {
-		if (!bodyValidator) return message;
-		if (bodyValidator.hasCodec) return bodyValidator.From(message, "body");
-		if (bodyValidator instanceof require_validator_index.StandardValidator) return bodyValidator.From(message, "body");
-		return bodyValidator.EncodeFrom(message, "body");
-	}
 	function onMessageValidationError(ws, error) {
 		if (errorHandlers.length === 0) {
 			if (require_generation.frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails && error instanceof require_error.ValidationError) error.allowUnsafeValidationDetails = true;
@@ -294,7 +289,6 @@ function buildWSRoute(route, app) {
 		}
 		return handleError(ws, error);
 	}
-	const messageHandlerTouchesBody = !!bodyValidator || handlerMayTouchBody(hook.message) || errorHandlers.some(handlerMayTouchBody);
 	const syncDispatchEligible = transforms.length === 0 && messageBeforeHandles.length === 0 && afterHandles.length === 0 && afterResponses.length === 0 && mapResponses.length === 0;
 	function finishMessageResult(ws, value) {
 		if (value === void 0) return;
@@ -309,7 +303,7 @@ function buildWSRoute(route, app) {
 		if (bodyValidator) {
 			let decoded;
 			try {
-				decoded = validateMessageBody(message);
+				decoded = validateUpgradeChannel(bodyValidator, message, "body");
 			} catch (error) {
 				return onMessageValidationError(ws, error);
 			}
@@ -320,7 +314,7 @@ function buildWSRoute(route, app) {
 	}
 	function runMessageSync(ws, message) {
 		try {
-			if (messageHandlerTouchesBody) ws.body = message;
+			ws.body = message;
 			const result = hook.message(ws, message);
 			if (result instanceof Promise) return result.then((resolved) => finishMessageResult(ws, resolved), (error) => handleError(ws, error));
 			return finishMessageResult(ws, result);
@@ -406,19 +400,37 @@ function buildWSRoute(route, app) {
 				if (r instanceof Promise) r = await r;
 				context.params = r;
 			}
-			if (validators.query) {
+			if (validators.query || inference.query) {
 				const url = request.url;
-				const query = require_parse_query.parseQueryFromURL(url, context.qi ?? url.indexOf("?"), queryArray, queryObject);
-				let r = validateUpgradeChannel(validators.query, query, "query");
-				if (r instanceof Promise) r = await r;
+				let r = require_parse_query.parseQueryFromURL(url, context.qi ?? url.indexOf("?"), queryArray, queryObject);
+				if (validators.query) {
+					r = validateUpgradeChannel(validators.query, r, "query");
+					if (r instanceof Promise) r = await r;
+				}
 				context.query = r;
 			}
-			if (validators.headers) {
-				const headers = require_universal_constants.isBun ? request.headers.toJSON() : Object.fromEntries(request.headers);
-				let r = validateUpgradeChannel(validators.headers, headers, "headers");
-				if (r instanceof Promise) r = await r;
+			if (validators.headers || inference.headers) {
+				let r = require_universal_constants.isBun ? request.headers.toJSON() : Object.fromEntries(request.headers);
+				if (validators.headers) {
+					r = validateUpgradeChannel(validators.headers, r, "headers");
+					if (r instanceof Promise) r = await r;
+				}
 				context.headers = r;
 			}
+			if (cookieConfig) {
+				const cookieHeader = request.headers.get("cookie");
+				if (validators.cookie) {
+					const raw = await require_cookie_utils.parseCookieRaw(cookieHeader, cookieConfig);
+					let r = raw;
+					if (!cookieIsOptional || Object.keys(raw).length) {
+						r = validateUpgradeChannel(validators.cookie, raw, "cookie");
+						if (r instanceof Promise) r = await r;
+					}
+					context.cookie = require_cookie_utils.buildCookieJar(context.set, r, cookieConfig);
+				} else if (!cookieConfig.hasSign) context.cookie = require_cookie_utils.buildCookieJar(context.set, require_cookie_utils.parseCookieRawDeferred(cookieHeader, cookieConfig), cookieConfig, void 0, 1);
+				else if (require_cookie_crypto.hasSyncHmac && cookieConfig.verify === "lazy") context.cookie = require_cookie_utils.buildCookieJar(context.set, require_cookie_utils.parseCookieRawLazy(cookieHeader, cookieConfig), cookieConfig, 1);
+				else context.cookie = require_cookie_utils.buildCookieJar(context.set, await require_cookie_utils.parseCookieRaw(cookieHeader, cookieConfig, cookieConfig.verify === "lazy" ? 1 : void 0), cookieConfig);
+			}
 			for (let i = 0; i < transforms.length; i++) {
 				const r = transforms[i](context);
 				if (r instanceof Promise) await r;
@@ -430,9 +442,10 @@ function buildWSRoute(route, app) {
 				const deriveMode = upgradeDeriveModes?.[i];
 				if (deriveMode !== void 0 && !(r instanceof require_error.ElysiaStatus)) {
 					if (r && typeof r === "object") if (deriveMode) context = require_compile_handler_utils.replaceDeriveContext(context, r);
-					else Object.assign(context, r);
+					else require_utils.assignOwn(context, r);
 				} else if (r !== void 0) {
 					if (r instanceof Response) return r;
+					if (signCookies) await signCookies(context.set);
 					return require_adapter_web_standard_handler.mapResponse(r, context.set, context.request);
 				}
 			}
@@ -465,7 +478,11 @@ function buildWSRoute(route, app) {
 				}
 			})) return new Response("Expected a websocket connection", { status: 400 });
 		} catch (error) {
-			return handleUpgradeError(context, error);
+			try {
+				return await handleUpgradeError(context, error);
+			} catch (thrown) {
+				return require_handler_utils.finalizeRouteError(app, context, thrown, signCookies);
+			}
 		}
 	};
 	const options = require_utils.nullObject();
@@ -475,33 +492,46 @@ function buildWSRoute(route, app) {
 function resolveWSOptions(entries) {
 	if (!entries || entries.length === 0) return void 0;
 	if (entries.length === 1) return { ...entries[0].value };
-	const ordered = entries.map((entry, index) => ({
-		entry,
-		index
-	})).sort((a, b) => b.entry.depth - a.entry.depth || a.index - b.index);
+	const ordered = entries.toSorted((a, b) => b.depth - a.depth);
 	const result = {};
 	let warned;
-	for (const { entry } of ordered) for (const key in entry.value) {
+	for (const entry of ordered) for (const key in entry.value) {
 		const incoming = entry.value[key];
 		if (key in result && result[key] !== incoming && !warned?.has(key)) {
 			(warned ??= /* @__PURE__ */ new Set()).add(key);
-			console.warn(`[Elysia] Conflicting WebSocket option '${key}' across .use(websocket()) registrations; the shallowest (nearest-root) registration wins.`);
+			console.warn(`[Elysia] Conflicting WebSocket option '${key}' across .use(websocket()). Using nearest-root registration.`);
 		}
 		result[key] = incoming;
 	}
 	return result;
 }
-function accumulateWSOptions(target, routeOptions, _path) {
-	if (!require_utils.isNotEmpty(routeOptions)) return;
-	if (require_universal_constants.isBun) {
-		for (const key in routeOptions) if (key in target && target[key] !== routeOptions[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);
+const wsLimits = [
+	"maxPayloadLength",
+	"backpressureLimit",
+	"idleTimeout"
+];
+const routeOwnedKeys = /* @__PURE__ */ new WeakMap();
+function accumulateWSOptions(target, routeOptions) {
+	let owned = routeOwnedKeys.get(target);
+	if (!owned) routeOwnedKeys.set(target, owned = /* @__PURE__ */ new Set());
+	for (const key in routeOptions) {
+		const incoming = routeOptions[key];
+		const current = target[key];
+		if (key in target && current !== incoming) {
+			if (require_universal_constants.isBun) {
+				console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (for limits the strictest route wins, otherwise the last-registered route).`);
+				console.warn((/* @__PURE__ */ new Error()).stack);
+			}
+			if (owned.has(key) && typeof current === "number" && typeof incoming === "number" && current < incoming && wsLimits.includes(key)) continue;
 		}
+		owned.add(key);
+		target[key] = incoming;
 	}
-	Object.assign(target, routeOptions);
 }
+const MAX_INFLIGHT_MESSAGES = 256;
 function buildGlobalWSHandler() {
+	let lifecycle;
+	const runLifecycle = (callback, ...args) => lifecycle ? lifecycle.run(callback, ...args) : callback(...args);
 	function getElysia(ws) {
 		let elysia = ws.data.elysia;
 		if (!elysia) {
@@ -516,39 +546,117 @@ function buildGlobalWSHandler() {
 			ws.send(typeof error?.message === "string" ? error.message : "Internal Server Error");
 		} catch {}
 	};
-	return {
+	const releaseLifecycle = (ws) => {
+		if (!lifecycle?.closing && require_utils.isSocketQuiet(ws)) {
+			delete ws.data["~lifecycleRun"];
+			lifecycle?.sockets.delete(ws);
+		}
+	};
+	const release = (ws) => {
+		const data = ws.data;
+		const inflight = data.inflight;
+		if (inflight) {
+			data.inflight = inflight - 1;
+			if (inflight === 1 && data.closeHandlerInvoked) releaseLifecycle(ws);
+		}
+	};
+	function dispatch(ws, message) {
+		let result;
+		try {
+			result = ws.data.message(getElysia(ws), message);
+		} catch (error) {
+			release(ws);
+			sendErrMsg(ws, error);
+			return;
+		}
+		if (result instanceof Promise) result.then(() => release(ws), (error) => {
+			release(ws);
+			sendErrMsg(ws, error);
+		});
+		else release(ws);
+	}
+	const handler = {
 		message(ws, message) {
-			let result;
-			try {
-				result = ws.data.message?.(getElysia(ws), message);
-			} catch (error) {
-				sendErrMsg(ws, error);
+			if (lifecycle?.closing) return;
+			const data = ws.data;
+			if (!data.message) return;
+			const inflight = (data.inflight ?? 0) + 1;
+			if (inflight > MAX_INFLIGHT_MESSAGES) {
+				try {
+					ws.close(1013, "Too many in-flight messages");
+				} catch {}
 				return;
 			}
-			if (result instanceof Promise) result.catch((error) => sendErrMsg(ws, error));
+			data.inflight = inflight;
+			const opening = data.opening;
+			if (opening) return void opening.then(() => {
+				if (lifecycle?.closing || ws.readyState > 1) return release(ws);
+				dispatch(ws, message);
+			});
+			dispatch(ws, message);
 		},
 		open(ws) {
-			ws.data.open?.(getElysia(ws));
+			if (lifecycle) Object.defineProperty(ws.data, "~lifecycleRun", {
+				configurable: true,
+				value: lifecycle.run
+			});
+			lifecycle?.sockets.add(ws);
+			if (lifecycle?.closing) {
+				ws.data.closeHandlerInvoked = true;
+				try {
+					ws.terminate();
+				} catch {}
+				return;
+			}
+			const open = ws.data.open;
+			const result = open && runLifecycle(open, getElysia(ws));
+			if (result instanceof Promise) {
+				const clear = () => {
+					ws.data.opening = void 0;
+					releaseLifecycle(ws);
+				};
+				ws.data.opening = result.then(clear, clear);
+			}
 		},
 		drain(ws) {
+			if (lifecycle?.closing) return;
 			const elyWs = getElysia(ws);
 			drainWaiters(elyWs);
-			ws.data.drain?.(elyWs);
+			const drain = ws.data.drain;
+			require_ws_context.trackWSSettling(ws.data, drain && runLifecycle(drain, elyWs), () => releaseLifecycle(ws));
 		},
 		close(ws, code, reason) {
 			const elyWs = getElysia(ws);
 			drainWaiters(elyWs);
-			if (ws.data.closeHandlerInvoked) return;
+			if (ws.data.closeHandlerInvoked) return releaseLifecycle(ws);
 			ws.data.closeHandlerInvoked = true;
-			ws.data.close?.(elyWs, code, reason);
+			let result;
+			try {
+				const close = ws.data.close;
+				result = close && runLifecycle(close, elyWs, code, reason);
+			} finally {
+				if (!(result instanceof Promise)) releaseLifecycle(ws);
+			}
+			if (result instanceof Promise) {
+				const closing = result.catch(() => {});
+				require_ws_context.trackWSSettling(ws.data, closing, () => releaseLifecycle(ws));
+			}
 		},
 		ping(ws, data) {
-			ws.data.ping?.(getElysia(ws), data);
+			if (lifecycle?.closing) return;
+			const ping = ws.data.ping;
+			require_ws_context.trackWSSettling(ws.data, ping && runLifecycle(ping, getElysia(ws), data), () => releaseLifecycle(ws));
 		},
 		pong(ws, data) {
-			ws.data.pong?.(getElysia(ws), data);
+			if (lifecycle?.closing) return;
+			const pong = ws.data.pong;
+			require_ws_context.trackWSSettling(ws.data, pong && runLifecycle(pong, getElysia(ws), data), () => releaseLifecycle(ws));
 		}
 	};
+	Object.defineProperty(handler, "~lifecycle", { set(value) {
+		lifecycle = value;
+	} });
+	return handler;
 }
 
 //#endregion