elysia 2.0.0-exp.46 → 2.0.0-exp.47

package/dist/adapter/index.d.ts

@@ -1,7 +1,7 @@
 import { ElysiaAdapterOptions } from "./types.js";
 
 //#region src/adapter/index.d.ts
-declare function createAdapter<const T extends ElysiaAdapterOptions>(adapter: ElysiaAdapterOptions): T;
+declare const createAdapter: (adapter: ElysiaAdapterOptions) => ElysiaAdapterOptions;
 type ElysiaAdapter = ReturnType<typeof createAdapter>;
 //#endregion
 export { ElysiaAdapter, type ElysiaAdapterOptions, createAdapter };

package/dist/adapter/index.js

@@ -1,9 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/adapter/index.ts
-function createAdapter(adapter) {
-	return adapter;
-}
+const createAdapter = (adapter) => adapter;
 
 //#endregion
 exports.createAdapter = createAdapter;

package/dist/adapter/index.mjs

@@ -1,7 +1,5 @@
 //#region src/adapter/index.ts
-function createAdapter(adapter) {
-	return adapter;
-}
+const createAdapter = (adapter) => adapter;
 
 //#endregion
 export { createAdapter };

package/dist/adapter/response-ownership.d.ts

@@ -0,0 +1,5 @@
+//#region src/adapter/response-ownership.d.ts
+declare function borrow<const T extends Response>(response: T): T;
+declare const isBorrowedResponse: (response: Response) => boolean;
+//#endregion
+export { borrow, isBorrowedResponse };

package/dist/adapter/response-ownership.js

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/adapter/response-ownership.ts
+const borrowedResponses = /* @__PURE__ */ new WeakSet();
+function borrow(response) {
+	borrowedResponses.add(response);
+	return response;
+}
+const isBorrowedResponse = (response) => borrowedResponses.has(response);
+
+//#endregion
+exports.borrow = borrow;
+exports.isBorrowedResponse = isBorrowedResponse;

package/dist/adapter/response-ownership.mjs

@@ -0,0 +1,10 @@
+//#region src/adapter/response-ownership.ts
+const borrowedResponses = /* @__PURE__ */ new WeakSet();
+function borrow(response) {
+	borrowedResponses.add(response);
+	return response;
+}
+const isBorrowedResponse = (response) => borrowedResponses.has(response);
+
+//#endregion
+export { borrow, isBorrowedResponse };

package/dist/adapter/utils.d.ts

@@ -17,16 +17,16 @@ declare function responseToSetHeaders(response: Response, set?: Context['set']):
   status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
 };
 interface CreateHandlerParameter {
-  mapResponse(response: unknown, set: Context['set'], request?: Request): Response;
-  mapCompactResponse(response: unknown, request?: Request): Response;
+  mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;
+  mapCompactResponse(response: unknown, request?: Request, owned?: boolean): Response;
 }
 declare function createStreamHandler({
   mapResponse,
   mapCompactResponse
-}: CreateHandlerParameter): (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean) => Promise<Response>;
+}: CreateHandlerParameter): (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean, owned?: boolean) => Promise<Response>;
 declare function streamResponse(response: Response): AsyncGenerator<any, void, any>;
 declare function handleSet(set: Context['set']): void;
-declare function createResponseHandler(handler: CreateHandlerParameter): (response: Response, set?: Context["set"], request?: Request) => any;
+declare function createResponseHandler(handler: CreateHandlerParameter): (response: Response, set?: Context["set"], request?: Request, owned?: boolean) => any;
 /**
  * Split async source into `branches` independent iterators
  *

package/dist/adapter/utils.js

@@ -4,6 +4,7 @@ const require_constants = require('../constants.js');
 const require_utils = require('../utils.js');
 const require_adapter_skip_clone = require('./skip-clone.js');
 const require_cookie_serialize = require('../cookie/serialize.js');
+const require_adapter_response_ownership = require('./response-ownership.js');
 const require_adapter_default_headers = require('./default-headers.js');
 
 //#region src/adapter/utils.ts
@@ -143,29 +144,49 @@ function enqueueBinaryChunk(controller, chunk) {
 	return false;
 }
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
-	return async (generator, set, request, skipFormat) => {
-		let init = generator.next?.();
+	return async (generator, set, request, skipFormat, owned = false) => {
+		if (require_utils.isByteStream(generator)) {
+			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
+			if (set) {
+				handleSet(set);
+				const headers = materializeSetHeaders(set);
+				if (headers instanceof Headers) {
+					if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+				} else if (!headers["content-type"]) headers["content-type"] = "application/octet-stream";
+				return new Response(generator, set);
+			}
+			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
+		}
+		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		let init = typedSSE ? void 0 : generator.next?.();
 		if (set) handleSet(set);
 		if (init instanceof Promise) init = await init;
 		if (init?.value instanceof ReadableStream) generator = init.value;
 		else if (init && (typeof init?.done === "undefined" || init?.done)) {
-			if (set) return mapResponse(init.value, set, request);
-			return mapCompactResponse(init.value, request);
+			if (set) return mapResponse(init.value, set, request, owned);
+			return mapCompactResponse(init.value, request, owned);
 		}
-		const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
+		const isSSE = typedSSE || !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
 		const format = isSSE ? sseFormat : identityFormat;
 		const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
 		if (set) materializeSetHeaders(set);
 		const headers = set?.headers;
 		if (headers instanceof Headers) {
-			if (!headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
+			if (!typedSSE && !headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
 			if (!headers.has("content-type")) headers.set("content-type", contentType);
 			if (!headers.has("cache-control")) headers.set("cache-control", "no-cache");
 		} else if (headers) {
-			if (!headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
+			if (!typedSSE && !headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
 			if (!headers["content-type"]) headers["content-type"] = contentType;
 			if (!headers["cache-control"]) headers["cache-control"] = "no-cache";
-		} else set = {
+		} else if (typedSSE) set = {
+			status: 200,
+			headers: {
+				"content-type": contentType,
+				"cache-control": "no-cache"
+			}
+		};
+		else set = {
 			status: 200,
 			headers: {
 				"content-type": contentType,
@@ -250,7 +271,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				cleanupAbort();
 				safeReturn();
 			}
-		}), set);
+		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};
 }
 async function* streamResponse(response) {
@@ -310,7 +331,7 @@ function mergeStatus(responseStatus, setStatus) {
 	if (responseStatus === 200) return setStatus;
 	return responseStatus;
 }
-function cancelPropagatingBody(clonedBody, orphanedBranch) {
+function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
 		async pull(controller) {
@@ -319,23 +340,42 @@ function cancelPropagatingBody(clonedBody, orphanedBranch) {
 			else controller.enqueue(value);
 		},
 		cancel(reason) {
+			if (preserveOrphan) {
+				reader.cancel(reason).catch(() => {});
+				return;
+			}
 			orphanedBranch.cancel(reason);
 			return reader.cancel(reason);
 		}
 	});
 }
+const warnedStreamBorrows = /* @__PURE__ */ new WeakSet();
 function createResponseHandler(handler) {
 	const handleStream = createStreamHandler(handler);
-	return (response, set, request) => {
+	return (response, set, request, owned = false) => {
+		if (require_adapter_skip_clone.skipClone.has(response) && !response.bodyUsed) {
+			require_adapter_skip_clone.skipClone.delete(response);
+			owned = true;
+		}
+		const explicitlyBorrowed = require_adapter_response_ownership.isBorrowedResponse(response);
+		const borrowed = !owned || explicitlyBorrowed;
+		const mustClone = owned && explicitlyBorrowed;
+		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests — a returned Response is request-owned; call borrow(response) to mark it reusable");
 		if (set) {
 			const status = mergeStatus(response.status, set.status);
-			if ((status === void 0 || status === response.status) && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
-		}
+			const statusUnchanged = status === void 0 || status === response.status;
+			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
+		} else if (!mustClone) return response;
+		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked — release the reader, or call borrow(response) if it must be reused");
 		let body = response.body;
-		if (require_adapter_skip_clone.skipClone.has(response) && !response.bodyUsed) require_adapter_skip_clone.skipClone.delete(response);
-		else {
+		if (borrowed) {
+			const bodyBefore = body;
 			const cloned = response.clone();
-			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body) : cloned.body;
+			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
+				warnedStreamBorrows.add(response);
+				console.warn("[elysia] borrow() was called on a stream-backed Response — its entire body will stay buffered in memory for as long as the borrowed object lives, and every reuse adds a tee layer. Borrow only buffered Responses (string / ArrayBuffer / Blob bodies), or construct a fresh Response per request.");
+			}
+			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
 		}
 		const newResponse = new Response(body, set ? {
 			headers: mergeHeaders(response.headers, set.headers),
@@ -346,7 +386,7 @@ function createResponseHandler(handler) {
 			status: response.status,
 			statusText: response.statusText
 		});
-		if (!newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
+		if (borrowed && !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
 		return newResponse;
 	};
 }

package/dist/adapter/utils.mjs

@@ -1,8 +1,9 @@
 import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
-import { isNotEmpty, nullObject } from "../utils.mjs";
+import { isByteStream, isNotEmpty, nullObject } from "../utils.mjs";
 import { skipClone } from "./skip-clone.mjs";
 import { serializeCookie } from "../cookie/serialize.mjs";
+import { isBorrowedResponse } from "./response-ownership.mjs";
 import { defaultHeaders } from "./default-headers.mjs";
 
 //#region src/adapter/utils.ts
@@ -142,29 +143,49 @@ function enqueueBinaryChunk(controller, chunk) {
 	return false;
 }
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
-	return async (generator, set, request, skipFormat) => {
-		let init = generator.next?.();
+	return async (generator, set, request, skipFormat, owned = false) => {
+		if (isByteStream(generator)) {
+			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
+			if (set) {
+				handleSet(set);
+				const headers = materializeSetHeaders(set);
+				if (headers instanceof Headers) {
+					if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+				} else if (!headers["content-type"]) headers["content-type"] = "application/octet-stream";
+				return new Response(generator, set);
+			}
+			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
+		}
+		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		let init = typedSSE ? void 0 : generator.next?.();
 		if (set) handleSet(set);
 		if (init instanceof Promise) init = await init;
 		if (init?.value instanceof ReadableStream) generator = init.value;
 		else if (init && (typeof init?.done === "undefined" || init?.done)) {
-			if (set) return mapResponse(init.value, set, request);
-			return mapCompactResponse(init.value, request);
+			if (set) return mapResponse(init.value, set, request, owned);
+			return mapCompactResponse(init.value, request, owned);
 		}
-		const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
+		const isSSE = typedSSE || !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
 		const format = isSSE ? sseFormat : identityFormat;
 		const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
 		if (set) materializeSetHeaders(set);
 		const headers = set?.headers;
 		if (headers instanceof Headers) {
-			if (!headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
+			if (!typedSSE && !headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
 			if (!headers.has("content-type")) headers.set("content-type", contentType);
 			if (!headers.has("cache-control")) headers.set("cache-control", "no-cache");
 		} else if (headers) {
-			if (!headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
+			if (!typedSSE && !headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
 			if (!headers["content-type"]) headers["content-type"] = contentType;
 			if (!headers["cache-control"]) headers["cache-control"] = "no-cache";
-		} else set = {
+		} else if (typedSSE) set = {
+			status: 200,
+			headers: {
+				"content-type": contentType,
+				"cache-control": "no-cache"
+			}
+		};
+		else set = {
 			status: 200,
 			headers: {
 				"content-type": contentType,
@@ -249,7 +270,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				cleanupAbort();
 				safeReturn();
 			}
-		}), set);
+		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};
 }
 async function* streamResponse(response) {
@@ -309,7 +330,7 @@ function mergeStatus(responseStatus, setStatus) {
 	if (responseStatus === 200) return setStatus;
 	return responseStatus;
 }
-function cancelPropagatingBody(clonedBody, orphanedBranch) {
+function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
 		async pull(controller) {
@@ -318,23 +339,42 @@ function cancelPropagatingBody(clonedBody, orphanedBranch) {
 			else controller.enqueue(value);
 		},
 		cancel(reason) {
+			if (preserveOrphan) {
+				reader.cancel(reason).catch(() => {});
+				return;
+			}
 			orphanedBranch.cancel(reason);
 			return reader.cancel(reason);
 		}
 	});
 }
+const warnedStreamBorrows = /* @__PURE__ */ new WeakSet();
 function createResponseHandler(handler) {
 	const handleStream = createStreamHandler(handler);
-	return (response, set, request) => {
+	return (response, set, request, owned = false) => {
+		if (skipClone.has(response) && !response.bodyUsed) {
+			skipClone.delete(response);
+			owned = true;
+		}
+		const explicitlyBorrowed = isBorrowedResponse(response);
+		const borrowed = !owned || explicitlyBorrowed;
+		const mustClone = owned && explicitlyBorrowed;
+		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests — a returned Response is request-owned; call borrow(response) to mark it reusable");
 		if (set) {
 			const status = mergeStatus(response.status, set.status);
-			if ((status === void 0 || status === response.status) && !set.cookie && !isNotEmpty(set.headers)) return response;
-		}
+			const statusUnchanged = status === void 0 || status === response.status;
+			if (!mustClone && statusUnchanged && !set.cookie && !isNotEmpty(set.headers)) return response;
+		} else if (!mustClone) return response;
+		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked — release the reader, or call borrow(response) if it must be reused");
 		let body = response.body;
-		if (skipClone.has(response) && !response.bodyUsed) skipClone.delete(response);
-		else {
+		if (borrowed) {
+			const bodyBefore = body;
 			const cloned = response.clone();
-			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body) : cloned.body;
+			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
+				warnedStreamBorrows.add(response);
+				console.warn("[elysia] borrow() was called on a stream-backed Response — its entire body will stay buffered in memory for as long as the borrowed object lives, and every reuse adds a tee layer. Borrow only buffered Responses (string / ArrayBuffer / Blob bodies), or construct a fresh Response per request.");
+			}
+			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
 		}
 		const newResponse = new Response(body, set ? {
 			headers: mergeHeaders(response.headers, set.headers),
@@ -345,7 +385,7 @@ function createResponseHandler(handler) {
 			status: response.status,
 			statusText: response.statusText
 		});
-		if (!newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
+		if (borrowed && !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
 		return newResponse;
 	};
 }

package/dist/adapter/web-standard/handler.d.ts

@@ -2,10 +2,10 @@ import { MaybePromise } from "../../types.js";
 import { Context } from "../../context.js";
 
 //#region src/adapter/web-standard/handler.d.ts
-declare function mapResponse(response: unknown, set: Context['set'], request?: Request): Response;
-declare function mapCompactResponse(response: unknown, request?: Request): Response;
+declare function mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;
+declare function mapCompactResponse(response: unknown, request?: Request, owned?: boolean): Response;
 declare function errorToResponse(error: Error & {
   toResponse?(): MaybePromise<Response>;
-}, set?: Context['set']): any;
+}, set?: Context['set'], request?: Request, owned?: boolean): any;
 //#endregion
 export { errorToResponse, mapCompactResponse, mapResponse };

package/dist/adapter/web-standard/handler.js

@@ -7,6 +7,7 @@ const require_adapter_default_headers = require('../default-headers.js');
 const require_adapter_utils = require('../utils.js');
 
 //#region src/adapter/web-standard/handler.ts
+const textPlainInit = { headers: { "content-type": "text/plain" } };
 function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {
 	const path = file.path;
 	const contentType = require_universal_file.mime[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
@@ -20,23 +21,17 @@ function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, r
 	});
 	return require_adapter_utils.handleFile(file.value, set, request);
 }
-function responseTag(response) {
-	if (response === null || response === void 0) return void 0;
-	const proto = Object.getPrototypeOf(response);
-	if (proto === null) return "Object";
-	return proto.constructor?.name;
-}
-function mapResponseWithSet(response, set, request) {
+function mapResponseWithSet(response, set, request, owned) {
 	require_adapter_utils.handleSet(set);
 	const headers = set.headers;
-	switch (responseTag(response)) {
+	switch (response?.constructor?.name) {
 		case "String":
 			if (!require_universal_constants.isBun && !headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = "text/plain";
 			return new Response(response, set);
 		case "Array": return Response.json(response, set);
 		case "Object":
 			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response), set);
-			if (typeof response?.next === "function") return handleStream(response, set, request);
+			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
 			return Response.json(response, set);
 		case "Number":
 		case "Boolean": return new Response(response.toString(), set);
@@ -46,32 +41,33 @@ function mapResponseWithSet(response, set, request) {
 		case "ElysiaStatus":
 			set.status = response.code;
 			if (response.headers) Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
-			return mapResponseWithSet(response.response, set, request);
+			return mapResponseWithSet(response.response, set, request, owned);
 		case void 0: return response ? Response.json(response, set) : new Response(null, set);
-		case "Response": return handleResponse(response, set, request);
-		case "Error": return errorToResponse(response, set);
-		case "Promise": return response.then((x) => mapResponseWithSet(x, set, request));
-		case "Function": return mapResponseWithSet(response(), set, request);
+		case "Response": return handleResponse(response, set, request, owned);
+		case "Error": return errorToResponse(response, set, request, owned);
+		case "Promise": return response.then((x) => mapResponseWithSet(x, set, request, owned));
+		case "Function": return mapResponseWithSet(response(), set, request, owned);
 		case "FormData": return new Response(response, set);
-		default: return mapResponseFallback(response, set, request);
+		default: return mapResponseFallback(response, set, request, owned);
 	}
 }
-function mapResponse(response, set, request) {
+function mapResponse(response, set, request, owned) {
 	const headers = set.headers;
-	if (set.status !== void 0 || set.cookie || headers["\0"] === headers || require_utils.isNotEmpty(headers)) return mapResponseWithSet(response, set, request);
+	if (set.status !== void 0 || set.cookie || headers["\0"] === headers || require_utils.isNotEmpty(headers)) return mapResponseWithSet(response, set, request, owned);
 	if (response instanceof require_error.ElysiaStatus) {
 		set.status = response.code;
 		if (response.headers) Object.assign(set.headers, response.headers);
-		return mapResponse(response.response, set, request);
+		return mapResponse(response.response, set, request, owned);
 	}
-	if (response instanceof Response) return response;
-	if (response instanceof Promise) return response.then((x) => mapResponse(x, set, request));
-	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request);
-	return mapCompactResponse(response, request);
+	if (response instanceof Response) return owned ? handleResponse(response, void 0, request, true) : response;
+	if (response instanceof Promise) return response.then((x) => mapResponse(x, set, request, owned));
+	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
+	return mapCompactResponse(response, request, owned);
 }
-function mapCompactResponse(response, request) {
-	switch (responseTag(response)) {
-		case "String": return new Response(response, require_universal_constants.isBun ? void 0 : { headers: { "content-type": "text/plain" } });
+const textHeaders = require_universal_constants.isBun ? void 0 : textPlainInit;
+function mapCompactResponse(response, request, owned) {
+	switch (response?.constructor?.name) {
+		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "Object":
 			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response));
@@ -84,22 +80,22 @@ function mapCompactResponse(response, request) {
 		case "ElysiaStatus": return mapResponse(response.response, {
 			status: response.code,
 			headers: response.headers ? Object.assign(require_utils.nullObject(), response.headers) : require_utils.nullObject()
-		});
+		}, request, owned);
 		case void 0: return response ? Response.json(response) : new Response("");
-		case "Response": return response;
-		case "Error": return errorToResponse(response);
-		case "Promise": return response.then((x) => mapCompactResponse(x, request));
-		case "Function": return mapCompactResponse(response(), request);
+		case "Response": return owned ? handleResponse(response, void 0, request, true) : response;
+		case "Error": return errorToResponse(response, void 0, request, owned);
+		case "Promise": return response.then((x) => mapCompactResponse(x, request, owned));
+		case "Function": return mapCompactResponse(response(), request, owned);
 		case "FormData": return new Response(response);
-		default: return mapCompactResponseFallback(response, void 0, request);
+		default: return mapCompactResponseFallback(response, void 0, request, owned);
 	}
 }
-function errorToResponse(error, set) {
+function errorToResponse(error, set, request, owned = false) {
 	if (error?.toResponse) {
 		const targetSet = set ?? { headers: require_utils.nullObject() };
 		const apply = (resolved) => {
 			if (resolved instanceof Response) targetSet.status = resolved.status;
-			return mapResponse(resolved, targetSet);
+			return mapResponse(resolved, targetSet, request, owned);
 		};
 		const raw = error.toResponse();
 		return typeof raw?.then === "function" ? raw.then(apply) : apply(raw);
@@ -115,31 +111,31 @@ function errorToResponse(error, set) {
 	});
 }
 function mapFallback(map) {
-	return (response, set, request) => {
-		if (response instanceof Response) return handleResponse(response, set, request);
-		if (response instanceof Promise) return response.then((x) => map(x, set, request));
-		if (response instanceof Error) return errorToResponse(response, set);
+	return (response, set, request, owned = false) => {
+		if (response instanceof Response) return handleResponse(response, set, request, owned);
+		if (response instanceof Promise) return response.then((x) => map(x, set, request, owned));
+		if (response instanceof Error) return errorToResponse(response, set, request, owned);
 		if (response instanceof require_error.ElysiaStatus) if (set) {
 			set.status = response.code;
 			if (response.headers) set.headers = {
 				...set.headers,
 				...response.headers
 			};
-			return map(response.response, set, request);
+			return map(response.response, set, request, owned);
 		} else return mapResponse(response.response, {
 			status: response.code,
 			headers: response.headers ? { ...response.headers } : {}
-		});
-		if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request);
-		if (typeof response?.then === "function") return response.then((x) => map(x, set, request));
+		}, request, owned);
+		if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
+		if (typeof response?.then === "function") return response.then((x) => map(x, set, request, owned));
 		if (Array.isArray(response)) return Response.json(response);
-		if (typeof response?.toResponse === "function") return map(response.toResponse(), set, request);
+		if (typeof response?.toResponse === "function") return map(response.toResponse(), set, request, owned);
 		if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
 		return new Response(response, set);
 	};
 }
 const mapResponseFallback = mapFallback(mapResponse);
-const mapCompactResponseFallback = mapFallback((response, _, request) => mapCompactResponse(response, request));
+const mapCompactResponseFallback = mapFallback((response, _, request, owned) => mapCompactResponse(response, request, owned));
 const handleResponse = require_adapter_utils.createResponseHandler({
 	mapResponse,
 	mapCompactResponse