@hono/node-server 1.2.1 → 1.2.2

package/dist/index.js

@@ -41,7 +41,6 @@ var import_node_http = require("http");
 
 // src/listener.ts
 var import_node_stream = require("stream");
-var import_promises = require("stream/promises");
 
 // src/globals.ts
 var import_node_crypto = __toESM(require("crypto"));
@@ -59,6 +58,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -81,7 +121,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -91,24 +131,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -120,6 +164,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/index.mjs

@@ -3,7 +3,6 @@ import { createServer as createServerHTTP } from "http";
 
 // src/listener.ts
 import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 
 // src/globals.ts
 import crypto from "crypto";
@@ -21,6 +20,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -43,7 +83,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -53,24 +93,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await pipeline(Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -82,6 +126,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/listener.js

@@ -34,7 +34,6 @@ __export(listener_exports, {
 });
 module.exports = __toCommonJS(listener_exports);
 var import_node_stream = require("stream");
-var import_promises = require("stream/promises");
 
 // src/globals.ts
 var import_node_crypto = __toESM(require("crypto"));
@@ -52,6 +51,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -74,7 +114,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -84,24 +124,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -113,6 +157,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/listener.mjs

@@ -1,6 +1,5 @@
 // src/listener.ts
 import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 
 // src/globals.ts
 import crypto from "crypto";
@@ -18,6 +17,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -40,7 +80,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -50,24 +90,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await pipeline(Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -79,6 +123,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/server.js

@@ -38,7 +38,6 @@ var import_node_http = require("http");
 
 // src/listener.ts
 var import_node_stream = require("stream");
-var import_promises = require("stream/promises");
 
 // src/globals.ts
 var import_node_crypto = __toESM(require("crypto"));
@@ -56,6 +55,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -78,7 +118,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -88,24 +128,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -117,6 +161,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/server.mjs

@@ -3,7 +3,6 @@ import { createServer as createServerHTTP } from "http";
 
 // src/listener.ts
 import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 
 // src/globals.ts
 import crypto from "crypto";
@@ -21,6 +20,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -43,7 +83,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -53,24 +93,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await pipeline(Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -82,6 +126,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/utils.d.mts

@@ -0,0 +1,5 @@
+import { Writable } from 'node:stream';
+
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+
+export { writeFromReadableStream };

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import { Writable } from 'node:stream';
+
+declare function writeFromReadableStream(stream: ReadableStream<Uint8Array>, writable: Writable): Promise<undefined> | undefined;
+
+export { writeFromReadableStream };

package/dist/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  writeFromReadableStream: () => writeFromReadableStream
+});
+module.exports = __toCommonJS(utils_exports);
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeFromReadableStream
+});

package/dist/utils.mjs

@@ -0,0 +1,43 @@
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+export {
+  writeFromReadableStream
+};

package/dist/vercel.js

@@ -36,7 +36,6 @@ module.exports = __toCommonJS(vercel_exports);
 
 // src/listener.ts
 var import_node_stream = require("stream");
-var import_promises = require("stream/promises");
 
 // src/globals.ts
 var import_node_crypto = __toESM(require("crypto"));
@@ -54,6 +53,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -76,7 +116,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -86,24 +126,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -115,6 +159,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/dist/vercel.mjs

@@ -1,6 +1,5 @@
 // src/listener.ts
 import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 
 // src/globals.ts
 import crypto from "crypto";
@@ -18,6 +17,47 @@ global.fetch = (info, init) => {
   return webFetch(info, init);
 };
 
+// src/utils.ts
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  }
+  const reader = stream.getReader();
+  if (writable.destroyed) {
+    reader.cancel();
+    return;
+  }
+  writable.on("drain", onDrain);
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+    writable.off("drain", onDrain);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      writable.destroy(error);
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (writable.write(value)) {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+
 // src/listener.ts
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
@@ -40,7 +80,7 @@ var getRequestListener = (fetchCallback) => {
     }
     let res;
     try {
-      res = await fetchCallback(new Request(url.toString(), init));
+      res = await fetchCallback(new Request(url, init));
     } catch (e) {
       res = new Response(null, { status: 500 });
       if (e instanceof Error) {
@@ -50,24 +90,28 @@ var getRequestListener = (fetchCallback) => {
       }
     }
     const resHeaderRecord = {};
+    const cookies = [];
     for (const [k, v] of res.headers) {
-      resHeaderRecord[k] = v;
       if (k === "set-cookie") {
-        outgoing.setHeader(k, res.headers.getSetCookie(k));
+        cookies.push(v);
       } else {
-        outgoing.setHeader(k, v);
+        resHeaderRecord[k] = v;
       }
     }
-    outgoing.statusCode = res.status;
+    if (cookies.length > 0) {
+      resHeaderRecord["set-cookie"] = cookies;
+    }
     if (res.body) {
       try {
         if (resHeaderRecord["transfer-encoding"] || resHeaderRecord["content-encoding"] || resHeaderRecord["content-length"] || // nginx buffering variant
-        regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
-          await pipeline(Readable.fromWeb(res.body), outgoing);
+        resHeaderRecord["x-accel-buffering"] && regBuffer.test(resHeaderRecord["x-accel-buffering"]) || !regContentType.test(resHeaderRecord["content-type"])) {
+          outgoing.writeHead(res.status, resHeaderRecord);
+          await writeFromReadableStream(res.body, outgoing);
         } else {
-          const text = await res.text();
-          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
-          outgoing.end(text);
+          const buffer = await res.arrayBuffer();
+          resHeaderRecord["content-length"] = buffer.byteLength;
+          outgoing.writeHead(res.status, resHeaderRecord);
+          outgoing.end(new Uint8Array(buffer));
         }
       } catch (e) {
         const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
@@ -79,6 +123,7 @@ var getRequestListener = (fetchCallback) => {
         }
       }
     } else {
+      outgoing.writeHead(res.status, resHeaderRecord);
       outgoing.end();
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",