address pr reviews

Author: anonrig

packages/open-next/src/core/routing/util.ts

@@ -105,15 +105,14 @@ export function convertRes(res: OpenNextNodeResponse): InternalResult {
   const isBase64Encoded =
     isBinaryContentType(headers["content-type"]) ||
     !!headers["content-encoding"];
-  let index = 0;
   const body = new ReadableStream({
     pull(controller) {
-      if (!res._chunks || index >= res._chunks.length) {
+      if (!res._chunks || res._chunks.length === 0) {
         controller.close();
         return;
       }
 
-      controller.enqueue(res._chunks[index++]);
+      controller.enqueue(res._chunks.shift());
     },
   });
   return {

packages/open-next/src/utils/binary.ts

@@ -62,6 +62,6 @@ const commonBinaryMimeTypes = new Set([
 export function isBinaryContentType(contentType?: string | null) {
   if (!contentType) return false;
 
-  const value = contentType.split(";").at(0);
+  const value = contentType.split(";")[0];
   return commonBinaryMimeTypes.has(value);
 }

packages/open-next/src/utils/stream.ts

@@ -4,65 +4,63 @@ export async function fromReadableStream(
   stream: ReadableStream<Uint8Array>,
   base64?: boolean,
 ): Promise<string> {
-  const reader = stream.getReader();
   const chunks: Uint8Array[] = [];
   let totalLength = 0;
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      totalLength += value.length;
-    }
-
-    if (chunks.length === 0) {
-      return "";
-    }
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+    totalLength += chunk.length;
+  }
 
-    if (chunks.length === 1) {
-      return Buffer.from(chunks[0]).toString(base64 ? "base64" : "utf8");
-    }
+  if (chunks.length === 0) {
+    return "";
+  }
 
-    // Pre-allocate buffer with exact size to avoid reallocation
-    const buffer = Buffer.allocUnsafe(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      buffer.set(chunk, offset);
-      offset += chunk.length;
-    }
+  if (chunks.length === 1) {
+    return Buffer.from(chunks[0]).toString(base64 ? "base64" : "utf8");
+  }
 
-    return buffer.toString(base64 ? "base64" : "utf8");
-  } finally {
-    reader.releaseLock();
+  // Pre-allocate buffer with exact size to avoid reallocation
+  const buffer = Buffer.alloc(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.length;
   }
+
+  return buffer.toString(base64 ? "base64" : "utf8");
 }
 
 export function toReadableStream(
   value: string,
   isBase64?: boolean,
 ): ReadableStream {
-  const buffer = Buffer.from(value, isBase64 ? "base64" : "utf8");
-
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(buffer);
-      controller.close();
+  return new ReadableStream(
+    {
+      start(controller) {
+        // Defer the Buffer.from conversion to when the stream is actually read.
+        controller.enqueue(Buffer.from(value, isBase64 ? "base64" : "utf8"));
+        controller.close();
+      },
     },
-  });
+    { highWaterMark: 0 },
+  );
 }
 
 let maybeSomethingBuffer: Buffer | undefined;
 
 export function emptyReadableStream(): ReadableStream {
   if (process.env.OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE === "true") {
-    return new ReadableStream({
-      start(controller) {
-        maybeSomethingBuffer ??= Buffer.from("SOMETHING");
-        controller.enqueue(maybeSomethingBuffer);
-        controller.close();
+    return new ReadableStream(
+      {
+        pull(controller) {
+          maybeSomethingBuffer ??= Buffer.from("SOMETHING");
+          controller.enqueue(maybeSomethingBuffer);
+          controller.close();
+        },
       },
-    });
+      { highWaterMark: 0 },
+    );
   }
   return new ReadableStream({
     start(controller) {