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

package/dist/ws/route.mjs

@@ -1,88 +1,27 @@
 import { isBun } from "../universal/constants.mjs";
-import { deriveEntryFn, isNotEmpty, nullObject } from "../utils.mjs";
+import { assignOwn, deriveEntryFn, isSocketQuiet, nullObject } from "../utils.mjs";
 import { isBridgeLive } from "../type/bridge.mjs";
-import { isProduction } from "../universal/is-production.mjs";
-import { ElysiaError, ElysiaStatus, ValidationError, internalServerErrorBodyString, problemBody, problemResponse } from "../error.mjs";
+import { ElysiaError, ElysiaStatus, ValidationError, elysiaErrorProblem, internalServerErrorBodyString, problemBody, problemResponse } from "../error.mjs";
+import { hasSyncHmac } from "../cookie/crypto.mjs";
 import { mapResponse } from "../adapter/web-standard/handler.mjs";
 import { parseQueryFromURL } from "../parse-query.mjs";
+import { Capture, Compiled, aotDrift, warnAotDrift } from "../compile/aot.mjs";
 import { frozenRootOf } from "../generation.mjs";
-import { createErrorHandler } from "../handler/error.mjs";
+import { compileCookieConfig } from "../cookie/config.mjs";
+import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, signCookieValues } from "../cookie/utils.mjs";
+import { finalizeRouteError } from "../handler/utils.mjs";
+import { adoptErrorType, claimsProblemType, createErrorHandler, readAnnotation, resolveStatus, statusFallbackBody } from "../handler/error.mjs";
 import { deriveModes, getQueryParseChannels, replaceDeriveContext } from "../compile/handler/utils.mjs";
+import { sucrose } from "../sucrose.mjs";
 import { StandardValidator } from "../validator/index.mjs";
 import { RouteValidator } from "../validator/route.mjs";
 import { buildFrozenRouteValidator, isBridgeNotInitialized } from "../compile/handler/frozen-validator.mjs";
-import { composeRouteHook, localMacroRoot, resolveWSLocalHook } from "../compile/handler/index.mjs";
-import { ElysiaWS, isGeneratorObject } from "./context.mjs";
+import { composeRouteHook, localMacroRoot, resolveWSLocalHook, routeShape } from "../compile/handler/index.mjs";
+import { ElysiaWS, isGeneratorObject, trackWSSettling } from "./context.mjs";
 import { createMessageParser } from "./parser.mjs";
 
 //#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++) {
@@ -103,7 +42,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;
@@ -135,7 +73,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;
@@ -154,6 +92,38 @@ async function handleWSResponse(ws, value, mapResponses) {
 	const mapped = mapResponses.length ? await applyMapResponse(ws, value, mapResponses) : value;
 	ws.send(mapped);
 }
+function wsErrorFrameFallback(error) {
+	if (claimsProblemType(error)) try {
+		const status = 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(problemBody({
+			type: error.type ?? "about:blank",
+			...typeof error.code === "string" ? { code: error.code } : {},
+			detail,
+			status: served
+		}));
+		const serveMessage = () => problemFrame(statusFallbackBody(error, served));
+		const serveDetail = () => {
+			const detail = 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 = 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 = statusFallbackBody(error, error.status);
+		return typeof body === "object" ? JSON.stringify(body) : String(body);
+	}
+	return internalServerErrorBodyString(error);
+}
 function wsErrorFrame(error) {
 	if (error instanceof ValidationError) try {
 		return JSON.stringify(error.payload);
@@ -166,12 +136,7 @@ function wsErrorFrame(error) {
 	} catch {}
 	if (typeof error?.toResponse === "function") {
 		if (error instanceof ElysiaError && error.toResponse === ElysiaError.prototype.toResponse) try {
-			return JSON.stringify(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(problemBody(elysiaErrorProblem(error)));
 		} catch {}
 		try {
 			const r = error.toResponse();
@@ -180,13 +145,6 @@ function wsErrorFrame(error) {
 	}
 	return wsErrorFrameFallback(error);
 }
-function wsErrorFrameFallback(error) {
-	if (error?.status) {
-		const body = error.response !== void 0 ? error.response : isProduction() ? error.status >= 500 ? "Internal Server Error" : "" : error.message ?? "";
-		return typeof body === "object" ? JSON.stringify(body) : String(body);
-	}
-	return internalServerErrorBodyString(error);
-}
 function sendErrorFrame(ws, error) {
 	const frame = wsErrorFrame(error);
 	if (typeof frame === "string") {
@@ -202,9 +160,7 @@ function sendErrorFrame(ws, error) {
 	}, () => {});
 }
 function validateUpgradeChannel(validator, value, type) {
-	if (validator instanceof StandardValidator) return validator.From(value, type);
-	if (validator.hasCodec) return validator.From(value, type);
-	return validator.EncodeFrom(value, type);
+	return validator.hasCodec || validator instanceof StandardValidator ? validator.From(value, type) : validator.EncodeFrom(value, type);
 }
 const wsOptions = [
 	"maxPayloadLength",
@@ -217,14 +173,35 @@ const wsOptions = [
 ];
 function buildWSRoute(route, app) {
 	const hook = resolveWSLocalHook(localMacroRoot(route[7] ?? route[3] ?? app, app), route[4], app) ?? nullObject();
+	const instance = route[3] ?? app;
+	const appHookChain = route[5];
+	const inheritedChain = route[6];
+	const composed = composeRouteHook(instance, route[4], appHookChain, inheritedChain, app, route[7]) ?? hook;
 	let validators;
-	const frozenEager = isBridgeLive() ? void 0 : buildFrozenRouteValidator(hook, app, "WS", route[1]);
+	const programId = frozenRootOf(app)["~programId"];
+	const captured = Compiled.getHandler(programId, "WS", route[1]);
+	let live = false;
+	if (Capture.isCapturing()) Capture.handler({
+		method: "WS",
+		path: route[1],
+		alias: "",
+		code: "",
+		k: routeShape(composed, void 0, app)
+	});
+	else if (Compiled.hasProgram(programId)) {
+		const shape = routeShape(composed, void 0, app);
+		live = shape === void 0 || captured?.k !== shape;
+	}
+	const frozenEager = isBridgeLive() || live ? void 0 : buildFrozenRouteValidator(composed, app, "WS", route[1]);
 	if (frozenEager) validators = frozenEager;
 	else try {
-		validators = new RouteValidator(hook, {
+		validators = new RouteValidator(composed, {
 			models: frozenRootOf(app)["~ext"]?.models,
 			app,
-			aot: {
+			normalize: frozenRootOf(app)["~config"]?.normalize,
+			sanitize: frozenRootOf(app)["~config"]?.sanitize,
+			schemas: composed.schemas,
+			aot: live ? void 0 : {
 				method: "WS",
 				path: route[1]
 			},
@@ -232,23 +209,23 @@ function buildWSRoute(route, app) {
 		});
 	} catch (error) {
 		if (!isBridgeNotInitialized(error)) throw error;
-		const frozen = buildFrozenRouteValidator(hook, app, "WS", route[1]);
+		if (live) throw new Error(aotDrift("WS", route[1]), { cause: error });
+		const frozen = buildFrozenRouteValidator(composed, app, "WS", route[1]);
 		if (!frozen) throw error;
 		validators = frozen;
 	}
+	if (live && captured) 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 = 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 = composeRouteHook(instance, void 0, appHookChain, inheritedChain, app, route[7]) ?? {};
-	const parseHooks = hook.parse == null ? [] : Array.isArray(hook.parse) ? hook.parse : [hook.parse];
+	const flatAppHook = 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(deriveEntryFn)) : void 0;
 	const upgradeDeriveModes = deriveModes(allBeforeHandles, deriveEntries);
 	const messageBeforeHandles = allBeforeHandles.filter((fn) => !deriveSet?.has(fn));
@@ -256,8 +233,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 = 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 ? compileCookieConfig(composed.cookie, frozenRootOf(app)["~config"]?.cookie, frozenRootOf(app)["~ext"]?.models, composed.schemas) : void 0;
+	const signCookies = cookieConfig?.hasSign ? (set) => signCookieValues(set.cookie, cookieConfig) : void 0;
 	const parseMessage = createMessageParser(parseHooks);
-	const handleUpgradeError = createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => mapResponse(response, set, context?.request)), void 0, frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
+	const handleUpgradeError = createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => {
+		const map = () => mapResponse(response, set, context?.request);
+		const pending = signCookies?.(set);
+		return pending ? pending.then(map) : map();
+	}), frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
 	async function handleError(ws, error) {
 		const errCtx = Object.create(ws);
 		errCtx.error = error;
@@ -271,6 +271,7 @@ function buildWSRoute(route, app) {
 				break;
 			}
 			if (r !== void 0) {
+				r = adoptErrorType(r, error);
 				try {
 					await handleWSResponse(ws, r, mapResponses);
 				} catch {}
@@ -280,12 +281,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 StandardValidator) return bodyValidator.From(message, "body");
-		return bodyValidator.EncodeFrom(message, "body");
-	}
 	function onMessageValidationError(ws, error) {
 		if (errorHandlers.length === 0) {
 			if (frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails && error instanceof ValidationError) error.allowUnsafeValidationDetails = true;
@@ -293,7 +288,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;
@@ -308,7 +302,7 @@ function buildWSRoute(route, app) {
 		if (bodyValidator) {
 			let decoded;
 			try {
-				decoded = validateMessageBody(message);
+				decoded = validateUpgradeChannel(bodyValidator, message, "body");
 			} catch (error) {
 				return onMessageValidationError(ws, error);
 			}
@@ -319,7 +313,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);
@@ -405,19 +399,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 = parseQueryFromURL(url, context.qi ?? url.indexOf("?"), queryArray, queryObject);
-				let r = validateUpgradeChannel(validators.query, query, "query");
-				if (r instanceof Promise) r = await r;
+				let r = 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 = 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 = 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 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 = buildCookieJar(context.set, r, cookieConfig);
+				} else if (!cookieConfig.hasSign) context.cookie = buildCookieJar(context.set, parseCookieRawDeferred(cookieHeader, cookieConfig), cookieConfig, void 0, 1);
+				else if (hasSyncHmac && cookieConfig.verify === "lazy") context.cookie = buildCookieJar(context.set, parseCookieRawLazy(cookieHeader, cookieConfig), cookieConfig, 1);
+				else context.cookie = buildCookieJar(context.set, await 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;
@@ -429,9 +441,10 @@ function buildWSRoute(route, app) {
 				const deriveMode = upgradeDeriveModes?.[i];
 				if (deriveMode !== void 0 && !(r instanceof ElysiaStatus)) {
 					if (r && typeof r === "object") if (deriveMode) context = replaceDeriveContext(context, r);
-					else Object.assign(context, r);
+					else assignOwn(context, r);
 				} else if (r !== void 0) {
 					if (r instanceof Response) return r;
+					if (signCookies) await signCookies(context.set);
 					return mapResponse(r, context.set, context.request);
 				}
 			}
@@ -464,7 +477,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 finalizeRouteError(app, context, thrown, signCookies);
+			}
 		}
 	};
 	const options = nullObject();
@@ -474,33 +491,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 (!isNotEmpty(routeOptions)) return;
-	if (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 (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) {
@@ -515,39 +545,117 @@ function buildGlobalWSHandler() {
 			ws.send(typeof error?.message === "string" ? error.message : "Internal Server Error");
 		} catch {}
 	};
-	return {
+	const releaseLifecycle = (ws) => {
+		if (!lifecycle?.closing && 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;
+			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(() => {});
+				trackWSSettling(ws.data, closing, () => releaseLifecycle(ws));
+			}
 		},
 		ping(ws, data) {
-			ws.data.ping?.(getElysia(ws), data);
+			if (lifecycle?.closing) return;
+			const ping = ws.data.ping;
+			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;
+			trackWSSettling(ws.data, pong && runLifecycle(pong, getElysia(ws), data), () => releaseLifecycle(ws));
 		}
 	};
+	Object.defineProperty(handler, "~lifecycle", { set(value) {
+		lifecycle = value;
+	} });
+	return handler;
 }
 
 //#endregion

package/dist/ws/types.d.ts

@@ -1,5 +1,5 @@
-import { AfterResponseHandler, BaseMacro, DocumentDecoration, ErrorHandler, InlineHandlerResponse, InternalRoute, MapResponse, MaybeArray, MaybePromise, OptionalHandler, Prettify, RouteSchema, SingletonBase, TransformHandler } from "../types.js";
 import { Context } from "../context.js";
+import { AfterResponseHandler, BaseMacro, DocumentDecoration, ErrorHandler, InlineHandlerResponse, InternalRoute, MapResponse, MaybeArray, MaybePromise, OptionalHandler, Prettify, RouteSchema, SingletonBase, TransformHandler } from "../types.js";
 import { AnyElysia } from "../base.js";
 
 //#region src/ws/types.d.ts
@@ -151,7 +151,7 @@ interface WSCapability {
    * Fold a single route's server-tuning options into the build-local config,
    * warning on conflicting keys (Bun uses one global config per server).
    */
-  accumulateOptions(target: WSOptions, routeOptions: WSOptions, path: string): void;
+  accumulateOptions(target: WSOptions, routeOptions: WSOptions): void;
 }
 //#endregion
 export { AnyWSLocalHook, BufferSource, ElysiaWSLike, FlattenResponse, ServerWebSocket, ServerWebSocketSendStatus, WSCapability, WSHandlerResponse, WSHandlerResult, WSLocalHook, WSMessageHandler, WSOptions, WSOptionsEntry, WSParseHandler, WSResponseValidator, WSValidatorLike, WebSocketCompressor, WebSocketHandler, WebSocketReadyState };