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

package/dist/adapter/utils.mjs

@@ -1,6 +1,6 @@
-import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
+import { hasHeaderShorthand } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
-import { isByteStream, isNotEmpty, nullObject } from "../utils.mjs";
+import { isByteStream, isNotEmpty, nullObject, sseData } from "../utils.mjs";
 import { skipClone } from "./skip-clone.mjs";
 import { serializeCookie } from "../cookie/serialize.mjs";
 import { isBorrowedResponse } from "./response-ownership.mjs";
@@ -13,25 +13,19 @@ function materializeSetHeaders(set) {
 	if (headers["\0"] !== headers) return headers;
 	return set.headers = Object.assign(nullObject(), headers);
 }
-const sseFormat = (data) => `data: ${data}\n\n`;
+const sseFormat = (data) => sseData(data) + "\n";
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
-const encodeChunk = (s) => textEncoder.encode(s);
 function normalizeContentType(contentType) {
 	if (contentType === "application/json") return contentType;
 	const end = contentType.indexOf(";");
 	return (end === -1 ? contentType : contentType.slice(0, end)).trim().toLowerCase();
 }
 function handleFile(response, set, request, size = response.size) {
-	if (!isBun && response instanceof Promise) return response.then((res) => handleFile(res, set, request, size));
 	const rangeHeader = request?.headers.get("range");
 	if (rangeHeader) {
 		const match = /bytes=(\d*)-(\d*)/.exec(rangeHeader);
 		if (match) {
-			if (!match[1] && !match[2]) return new Response(null, {
-				status: 416,
-				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? nullObject())
-			});
 			let start;
 			let end;
 			if (!match[1] && match[2]) {
@@ -42,7 +36,7 @@ function handleFile(response, set, request, size = response.size) {
 				start = match[1] ? parseInt(match[1]) : 0;
 				end = match[2] ? Math.min(parseInt(match[2]), size - 1) : size - 1;
 			}
-			if (start >= size || start > end) return new Response(null, {
+			if (!match[1] && !match[2] || start >= size || start > end) return new Response(null, {
 				status: 416,
 				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? nullObject())
 			});
@@ -74,13 +68,9 @@ function handleFile(response, set, request, size = response.size) {
 		}
 		return new Response(body, set);
 	}
-	if (isNotEmpty(set.headers)) return new Response(body, {
-		status: set.status,
-		headers: Object.assign(defaultHeader, set.headers)
-	});
 	return new Response(body, {
 		status: set.status,
-		headers: defaultHeader
+		headers: Object.assign(defaultHeader, set.headers)
 	});
 }
 function normalizeHeaders(set) {
@@ -123,27 +113,9 @@ function responseToSetHeaders(response, set) {
 	if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
-function enqueueBinaryChunk(controller, chunk) {
-	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
-		controller.enqueue(new Uint8Array(buffer));
-		return true;
-	});
-	if (chunk instanceof Uint8Array) {
-		controller.enqueue(chunk);
-		return true;
-	}
-	if (chunk instanceof ArrayBuffer) {
-		controller.enqueue(new Uint8Array(chunk));
-		return true;
-	}
-	if (ArrayBuffer.isView(chunk)) {
-		controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-		return true;
-	}
-	return false;
-}
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
 	return async (generator, set, request, skipFormat, owned = false) => {
+		if (request === null) return void 0;
 		if (isByteStream(generator)) {
 			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
 			if (set) {
@@ -157,10 +129,12 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
 		}
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		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;
+		const yieldedStream = init?.value instanceof ReadableStream;
+		if (yieldedStream) generator = init.value;
 		else if (init && (typeof init?.done === "undefined" || init?.done)) {
 			if (set) return mapResponse(init.value, set, request, owned);
 			return mapCompactResponse(init.value, request, owned);
@@ -194,8 +168,32 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				connection: "keep-alive"
 			}
 		};
-		const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
+		const sourceStream = generator instanceof ReadableStream ? generator : void 0;
+		let streamReader;
+		const iterator = sourceStream ? {
+			next: () => (streamReader ??= sourceStream.getReader()).read(),
+			async return() {
+				if (!streamReader) {
+					await sourceStream.cancel();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+				try {
+					await streamReader.cancel();
+				} finally {
+					streamReader.releaseLock();
+				}
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		} : sourceIterator ?? generator[Symbol.asyncIterator]();
+		const outerIterator = yieldedStream && !init.done ? sourceIterator : void 0;
 		let end = false;
+		let finalizing;
 		const signal = request?.signal;
 		let onAbort;
 		const cleanupAbort = () => {
@@ -204,71 +202,93 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				onAbort = void 0;
 			}
 		};
-		const safeReturn = () => {
+		const safeReturn = async (target) => {
 			try {
-				const r = iterator.return?.();
-				if (r && typeof r.then === "function") r.catch(() => {});
+				await target?.return?.();
 			} catch {}
 		};
-		const closeSafely = (controller) => {
+		const finalize = (mode, controller, error) => {
+			if (end) return finalizing;
+			end = true;
+			cleanupAbort();
+			finalizing = safeReturn(iterator).then(() => safeReturn(outerIterator));
+			if (!controller) return finalizing;
 			try {
-				controller.close();
+				if (mode === "error") controller.error(error);
+				else controller.close();
 			} catch {}
-			cleanupAbort();
 		};
-		const enqueueValue = async (controller, value) => {
+		const enqueueValue = (controller, value) => {
 			if (value.toSSE) {
-				controller.enqueue(encodeChunk(value.toSSE()));
+				controller.enqueue(textEncoder.encode(value.toSSE()));
 				return;
 			}
-			const p = enqueueBinaryChunk(controller, value);
-			if (p !== false) return void await p;
+			let p;
+			if (value instanceof Blob) p = value.arrayBuffer().then((buffer) => {
+				controller.enqueue(new Uint8Array(buffer));
+			});
+			else if (value instanceof Uint8Array) {
+				controller.enqueue(value);
+				p = true;
+			} else if (value instanceof ArrayBuffer) {
+				controller.enqueue(new Uint8Array(value));
+				p = true;
+			} else if (ArrayBuffer.isView(value)) {
+				controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+				p = true;
+			} else p = false;
+			if (p !== false) return p === true ? void 0 : p;
 			if (typeof value === "object") try {
-				controller.enqueue(encodeChunk(format(JSON.stringify(value))));
+				controller.enqueue(textEncoder.encode(format(JSON.stringify(value))));
 			} catch {
-				controller.enqueue(encodeChunk(format(value.toString())));
+				controller.enqueue(textEncoder.encode(format(value.toString())));
 			}
-			else controller.enqueue(encodeChunk(format(value.toString())));
+			else controller.enqueue(textEncoder.encode(format(value.toString())));
 		};
 		return new Response(new ReadableStream({
-			async start(controller) {
+			start(controller) {
 				if (signal) {
-					onAbort = () => {
-						cleanupAbort();
-						end = true;
-						safeReturn();
-						try {
-							controller.close();
-						} catch {}
-					};
+					onAbort = () => finalize("close", controller);
 					if (signal.aborted) onAbort();
 					else signal.addEventListener("abort", onAbort, { once: true });
 				}
 				if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
-				await enqueueValue(controller, init.value);
-			},
-			async pull(controller) {
-				if (end) {
-					closeSafely(controller);
-					return;
-				}
+				const fail = (error) => {
+					finalize("error", controller, error);
+				};
 				try {
-					const { value: chunk, done } = await iterator.next();
-					if (done || end) {
-						closeSafely(controller);
-						return;
+					return enqueueValue(controller, init.value)?.catch(fail);
+				} catch (error) {
+					fail(error);
+				}
+			},
+			pull(controller) {
+				if (end) return;
+				const fail = (error) => {
+					finalize("error", controller, error);
+				};
+				const step = (result) => {
+					while (true) {
+						if (result.done || end) {
+							finalize("close", controller);
+							return;
+						}
+						const chunk = result.value;
+						if (chunk !== void 0 && chunk !== null) return enqueueValue(controller, chunk);
+						const next = iterator.next();
+						if (typeof next.then === "function") return Promise.resolve(next).then(step);
+						result = next;
 					}
-					if (chunk === void 0 || chunk === null) return;
-					await enqueueValue(controller, chunk);
+				};
+				try {
+					const next = iterator.next();
+					return (typeof next.then === "function" ? Promise.resolve(next).then(step) : step(next))?.catch(fail);
 				} catch (error) {
-					cleanupAbort();
-					controller.error(error);
+					fail(error);
 				}
 			},
 			cancel() {
-				end = true;
-				cleanupAbort();
-				safeReturn();
+				finalize("close");
 			}
 		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};
@@ -283,7 +303,7 @@ function handleSet(set) {
 	const proto = Object.getPrototypeOf(set.headers);
 	if (proto !== null && proto !== Object.prototype) {
 		const flat = Object.create(null);
-		for (const key in set.headers) flat[key] = set.headers[key];
+		for (const key of Object.keys(set.headers)) flat[key] = set.headers[key];
 		set.headers = flat;
 	}
 	if (set.cookie && isNotEmpty(set.cookie)) {
@@ -291,8 +311,11 @@ function handleSet(set) {
 		const cookie = serializeCookie(set.cookie);
 		if (cookie) {
 			const existing = set.headers[setCookie];
-			if (Array.isArray(existing)) set.headers[setCookie] = existing.concat(cookie);
-			else set.headers[setCookie] = cookie;
+			if (existing) {
+				const kept = typeof existing === "string" ? [existing] : existing;
+				const added = (typeof cookie === "string" ? [cookie] : cookie).filter((value) => !kept.includes(value));
+				set.headers[setCookie] = added.length ? kept.concat(added) : existing;
+			} else set.headers[setCookie] = cookie;
 		}
 	}
 	if (set.headers[setCookie] && Array.isArray(set.headers[setCookie])) set.headers = parseSetCookies(new Headers(set.headers), set.headers[setCookie]);
@@ -310,7 +333,7 @@ function applySetHeaders(target, setHeaders, present) {
 		for (const key of setHeaders.keys()) if (key !== setCookie && !present.has(key)) target.set(key, setHeaders.get(key) ?? "");
 	} else {
 		let cookies;
-		for (const key in setHeaders) if (key === setCookie) {
+		for (const key of Object.keys(setHeaders)) if (key === setCookie) {
 			const cookie = setHeaders[key];
 			cookies ??= target.getSetCookie();
 			if (!cookies.includes(cookie)) {
@@ -348,7 +371,6 @@ function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = fals
 		}
 	});
 }
-const warnedStreamBorrows = /* @__PURE__ */ new WeakSet();
 function createResponseHandler(handler) {
 	const handleStream = createStreamHandler(handler);
 	return (response, set, request, owned = false) => {
@@ -360,25 +382,21 @@ function createResponseHandler(handler) {
 		const borrowed = !owned || explicitlyBorrowed;
 		const mustClone = owned && explicitlyBorrowed;
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
+		let status;
 		if (set) {
-			const status = mergeStatus(response.status, set.status);
+			status = mergeStatus(response.status, set.status);
 			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");
 		let body = response.body;
 		if (borrowed) {
-			const bodyBefore = body;
 			const cloned = response.clone();
-			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
-				warnedStreamBorrows.add(response);
-				console.warn("[elysia] borrow() was called on a stream-backed Response");
-			}
 			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),
-			status: mergeStatus(response.status, set.status),
+			status,
 			statusText: response.statusText
 		} : {
 			headers: response.headers,
@@ -403,6 +421,46 @@ const doneResult = {
 	value: void 0
 };
 /**
+* A returned `ReadableStream` is consumed after the handler returns, so
+* afterResponse, `defer()` and derive dispose must wait for it the way a tee'd
+* generator is waited on
+*
+* A returned `Response` is not observed, reading `.body` would move
+* every Response on these routes off Bun's native send path; a `bytes()`
+* stream keeps its exact-stream contract and releases early as before
+*/
+function observeStream(source) {
+	if (source.locked || isByteStream(source)) return;
+	const reader = source.getReader();
+	const [value, observer] = tee({ [Symbol.asyncIterator]: () => ({
+		next: () => reader.read(),
+		return: (reason) => reader.cancel(reason).then(() => ({
+			done: true,
+			value: void 0
+		}))
+	}) });
+	const body = new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await value.next();
+				if (result.done) controller.close();
+				else controller.enqueue(result.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel(reason) {
+			return value.return?.(reason);
+		}
+	}, { highWaterMark: 0 });
+	if (source.sse === true) body.sse = true;
+	return [
+		body,
+		observer,
+		value
+	];
+}
+/**
 * Split async source into `branches` independent iterators
 *
 * A producer drains the source ahead of consumers
@@ -523,7 +581,7 @@ function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 			wakeAll();
 		}
 	})();
-	const makeBranch = (me) => ({
+	const makeBranch = (me) => Object.assign(Object.create(null), {
 		[Symbol.asyncIterator]() {
 			return this;
 		},
@@ -557,4 +615,4 @@ function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 }
 
 //#endregion
-export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, parseSetCookies, responseToSetHeaders, streamResponse, tee };
+export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, observeStream, parseSetCookies, responseToSetHeaders, streamResponse, tee };

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

@@ -1,5 +1,5 @@
-import { MaybePromise } from "../../types.js";
 import { Context } from "../../context.js";
+import { MaybePromise } from "../../types.js";
 
 //#region src/adapter/web-standard/handler.d.ts
 declare function mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;

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

@@ -2,17 +2,18 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../../universal/constants.js');
 const require_universal_file = require('../../universal/file.js');
 const require_utils = require('../../utils.js');
+const require_universal_is_production = require('../../universal/is-production.js');
 const require_error = require('../../error.js');
 const require_adapter_default_headers = require('../default-headers.js');
 const require_adapter_utils = require('../utils.js');
+const require_cookie_cookie = require('../../cookie/cookie.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()];
+	const contentType = file.type;
 	const headers = require_adapter_utils.materializeSetHeaders(set);
-	if (contentType) headers["content-type"] = contentType;
+	if (contentType !== "application/octet-stream") headers["content-type"] = contentType;
 	const stats = file.stats;
 	if (stats) return stats.then((stat) => {
 		const size = stat.size;
@@ -22,12 +23,16 @@ function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, r
 	return require_adapter_utils.handleFile(file.value, set, request);
 }
 function responseTag(response) {
+	if (typeof response === "string") return "String";
 	if (response == null) return;
-	return Object.getPrototypeOf(response)?.constructor?.name;
+	const constructor = Object.getPrototypeOf(response)?.constructor;
+	if (typeof constructor !== "function") return typeof response.next === "function" ? "" : void 0;
+	return constructor.name;
 }
 function mapResponseWithSet(response, set, request, owned) {
 	require_adapter_utils.handleSet(set);
 	const headers = set.headers;
+	if (!require_universal_constants.isBun && (set.status === 204 || set.status === 304 || set.status === 205) && !(response instanceof Response) && !(response instanceof require_error.ElysiaStatus)) return new Response(null, set);
 	switch (responseTag(response)) {
 		case "String":
 			if (!require_universal_constants.isBun && !headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = "text/plain";
@@ -38,14 +43,11 @@ function mapResponseWithSet(response, set, request, owned) {
 			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(typeof response === "boolean" ? response ? "true" : "false" : response.toString(), set);
+		case "Boolean": return new Response(String(response), set);
 		case "ElysiaFile": return handleElysiaFile(response, set, request);
 		case "File":
 		case "Blob": return require_adapter_utils.handleFile(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, owned);
+		case "ElysiaStatus": return withStatus(response, set, request, owned);
 		case void 0: return response ? Response.json(response, set) : new Response(null, set);
 		case "Response": return handleResponse(response, set, request, owned);
 		case "Error": return errorToResponse(response, set, request, owned);
@@ -55,14 +57,24 @@ function mapResponseWithSet(response, set, request, owned) {
 		default: return mapFallback(response, set, request, owned);
 	}
 }
+function withStatus(response, set, request, owned) {
+	if (set) set.status = response.status;
+	else set = {
+		status: response.status,
+		headers: require_utils.nullObject()
+	};
+	if (response.headers) Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
+	return mapResponseWithSet(response.response, set, request, owned);
+}
+const checkRemovedSetRedirect = !require_universal_is_production.isProduction();
 function mapResponse(response, set, request, owned) {
+	if (checkRemovedSetRedirect && Object.hasOwn(set, "redirect") && !require_universal_is_production.isProduction()) {
+		delete set.redirect;
+		throw new Error("[Elysia] set.redirect was removed in 2.0 — return redirect(url) instead");
+	}
 	const headers = set.headers;
 	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, owned);
-	}
+	if (response instanceof require_error.ElysiaStatus) return withStatus(response, set, request, owned);
 	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);
@@ -76,14 +88,11 @@ function mapCompactResponse(response, request, owned) {
 		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
 		case "Object": return Response.json(response);
 		case "Number":
-		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
+		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
 		case "File":
 		case "Blob": return require_adapter_utils.handleFile(response, void 0, 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 "ElysiaStatus": return withStatus(response, void 0, request, owned);
 		case void 0: return response ? Response.json(response) : new Response("");
 		case "Response": return owned ? handleResponse(response, void 0, request, true) : response;
 		case "Error": return errorToResponse(response, void 0, request, owned);
@@ -115,28 +124,30 @@ function errorToResponse(error, set, request, owned = false) {
 }
 function mapFallback(response, set, request, owned = false) {
 	if (response instanceof Response) return handleResponse(response, set, request, owned);
-	if (response instanceof Promise) return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, 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 mapResponse(response.response, set, request, owned);
-	} else return mapResponse(response.response, {
-		status: response.code,
-		headers: response.headers ? { ...response.headers } : {}
-	}, request, owned);
-	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (response instanceof require_error.ElysiaStatus) {
+		if (set && response.headers) {
+			set.status = response.status;
+			set.headers = {
+				...set.headers,
+				...response.headers
+			};
+			return mapResponse(response.response, set, request, owned);
+		}
+		return withStatus(response, set, request, owned);
+	}
+	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, set, request);
 	if (require_utils.isElysiaForm(response)) return new Response(require_utils.formToFormData(response), set);
 	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) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
-	if (Array.isArray(response)) return Response.json(response);
-	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (responseTag(response) === "Cookie") return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
+	if (typeof response?.then === "function") return response.then((x) => remap(x, set, request, owned));
+	if (Array.isArray(response)) return Response.json(response, set);
+	if (typeof response?.toResponse === "function") return remap(response.toResponse(), set, request, owned);
+	if (responseTag(response) === "Cookie" && require_cookie_cookie.Cookie.isCookie(response)) return remap(response.value, set, request, owned);
 	return new Response(response, set);
 }
+function remap(response, set, request, owned) {
+	return set ? mapResponse(response, set, request, owned) : mapCompactResponse(response, request, owned);
+}
 const handleResponse = require_adapter_utils.createResponseHandler({
 	mapResponse,
 	mapCompactResponse