@hono/node-server 1.17.0 → 1.18.0

package/dist/serve-static.mjs

@@ -1,7 +1,7 @@
 // src/serve-static.ts
 import { getMimeType } from "hono/utils/mime";
 import { createReadStream, lstatSync } from "fs";
-import { join, resolve } from "path";
+import { join } from "path";
 var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
 var ENCODINGS = {
   br: ".br",
@@ -34,37 +34,34 @@ var getStats = (path) => {
   return stats;
 };
 var serveStatic = (options = { root: "" }) => {
-  const root = resolve(options.root || ".");
+  const root = options.root || "";
   const optionPath = options.path;
   return async (c, next) => {
     if (c.finalized) {
       return next();
     }
     let filename;
-    try {
-      const rawPath = optionPath ?? c.req.path;
-      if (!optionPath) {
-        const decodedPath = decodeURIComponent(rawPath);
-        if (decodedPath.includes("..")) {
-          await options.onNotFound?.(rawPath, c);
-          return next();
+    if (optionPath) {
+      filename = optionPath;
+    } else {
+      try {
+        filename = decodeURIComponent(c.req.path);
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+          throw new Error();
         }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
       }
-      filename = optionPath ?? decodeURIComponent(c.req.path);
-    } catch {
-      await options.onNotFound?.(c.req.path, c);
-      return next();
     }
-    const requestPath = options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename;
-    let path = optionPath ? options.root ? resolve(join(root, optionPath)) : optionPath : resolve(join(root, requestPath));
+    let path = join(
+      root,
+      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
+    );
     let stats = getStats(path);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path = resolve(join(path, indexFile));
-      if (!optionPath && !path.startsWith(root)) {
-        await options.onNotFound?.(path, c);
-        return next();
-      }
+      path = join(path, indexFile);
       stats = getStats(path);
     }
     if (!stats) {

package/dist/server.js

@@ -287,30 +287,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -319,13 +313,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -367,8 +369,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -440,23 +440,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   if (res.body) {
-    const {
-      "transfer-encoding": transferEncoding,
-      "content-encoding": contentEncoding,
-      "content-length": contentLength,
-      "x-accel-buffering": accelBuffering,
-      "content-type": contentType
-    } = resHeaderRecord;
-    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
-    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
-      outgoing.writeHead(res.status, resHeaderRecord);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/server.mjs

@@ -252,30 +252,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -284,13 +278,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -332,8 +334,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -405,23 +405,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   if (res.body) {
-    const {
-      "transfer-encoding": transferEncoding,
-      "content-encoding": contentEncoding,
-      "content-length": contentLength,
-      "x-accel-buffering": accelBuffering,
-      "content-type": contentType
-    } = resHeaderRecord;
-    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
-    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
-      outgoing.writeHead(res.status, resHeaderRecord);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/utils.d.mts

@@ -1,7 +1,9 @@
 import { OutgoingHttpHeaders } from 'node:http';
 import { Writable } from 'node:stream';
 
+declare function readWithoutBlocking(readPromise: Promise<ReadableStreamReadResult<Uint8Array>>): Promise<ReadableStreamReadResult<Uint8Array> | undefined>;
+declare function writeFromReadableStreamDefaultReader(reader: ReadableStreamDefaultReader<Uint8Array>, writable: Writable, currentReadPromise?: Promise<ReadableStreamReadResult<Uint8Array>> | undefined): Promise<undefined>;
 declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
 declare const buildOutgoingHttpHeaders: (headers: Headers | HeadersInit | null | undefined) => OutgoingHttpHeaders;
 
-export { buildOutgoingHttpHeaders, writeFromReadableStream };
+export { buildOutgoingHttpHeaders, readWithoutBlocking, writeFromReadableStream, writeFromReadableStreamDefaultReader };

package/dist/utils.d.ts

@@ -1,7 +1,9 @@
 import { OutgoingHttpHeaders } from 'node:http';
 import { Writable } from 'node:stream';
 
+declare function readWithoutBlocking(readPromise: Promise<ReadableStreamReadResult<Uint8Array>>): Promise<ReadableStreamReadResult<Uint8Array> | undefined>;
+declare function writeFromReadableStreamDefaultReader(reader: ReadableStreamDefaultReader<Uint8Array>, writable: Writable, currentReadPromise?: Promise<ReadableStreamReadResult<Uint8Array>> | undefined): Promise<undefined>;
 declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
 declare const buildOutgoingHttpHeaders: (headers: Headers | HeadersInit | null | undefined) => OutgoingHttpHeaders;
 
-export { buildOutgoingHttpHeaders, writeFromReadableStream };
+export { buildOutgoingHttpHeaders, readWithoutBlocking, writeFromReadableStream, writeFromReadableStreamDefaultReader };

package/dist/utils.js

@@ -21,33 +21,29 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   buildOutgoingHttpHeaders: () => buildOutgoingHttpHeaders,
-  writeFromReadableStream: () => writeFromReadableStream
+  readWithoutBlocking: () => readWithoutBlocking,
+  writeFromReadableStream: () => writeFromReadableStream,
+  writeFromReadableStreamDefaultReader: () => writeFromReadableStreamDefaultReader
 });
 module.exports = __toCommonJS(utils_exports);
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -56,13 +52,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -85,5 +89,7 @@ var buildOutgoingHttpHeaders = (headers) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildOutgoingHttpHeaders,
-  writeFromReadableStream
+  readWithoutBlocking,
+  writeFromReadableStream,
+  writeFromReadableStreamDefaultReader
 });

package/dist/utils.mjs

@@ -1,28 +1,22 @@
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -31,13 +25,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -59,5 +61,7 @@ var buildOutgoingHttpHeaders = (headers) => {
 };
 export {
   buildOutgoingHttpHeaders,
-  writeFromReadableStream
+  readWithoutBlocking,
+  writeFromReadableStream,
+  writeFromReadableStreamDefaultReader
 };

package/dist/vercel.js

@@ -285,30 +285,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -317,13 +311,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -365,8 +367,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -438,23 +438,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   if (res.body) {
-    const {
-      "transfer-encoding": transferEncoding,
-      "content-encoding": contentEncoding,
-      "content-length": contentLength,
-      "x-accel-buffering": accelBuffering,
-      "content-type": contentType
-    } = resHeaderRecord;
-    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
-    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
-      outgoing.writeHead(res.status, resHeaderRecord);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {