Take the native blob path for Response-wrapped Bun.file() streams

src/runtime/server/RequestContext.rs

@@ -2910,9 +2910,29 @@ where
                         }
                         // toBlobIfPossible will typically convert .Blob streams, or .File streams into a Blob object, but cannot always.
                         readable_stream::Source::Blob(_)
-                        | readable_stream::Source::File(_)
+                        | readable_stream::Source::File(_) => {
+                            // `value.to_blob_if_possible()` above can no longer
+                            // see the stream once check_body_stream_ref has
+                            // migrated it into the JS-side cached slot, so
+                            // unread blob/file-backed Response streams land
+                            // here. Convert now so file streams take the
+                            // sendfile/native blob path instead of the
+                            // per-chunk JS streaming loop.
+                            let mut stream = stream;
+                            if let Some(blob) = stream.to_any_blob(global_this) {
+                                this.response_body_readable_stream_ref.deinit();
+                                this.blob = blob;
+                                this.render_with_blob_from_body_value();
+                                return;
+                            }
+                            if let Some(resp) = this.resp {
+                                let mut pair = StreamPair { stream, this };
+                                resp.run_corked_with_type(Self::do_render_stream, &raw mut pair);
+                            }
+                            return;
+                        }
                         // These are the common scenario:
-                        | readable_stream::Source::JavaScript
+                        readable_stream::Source::JavaScript
                         | readable_stream::Source::Direct => {
                             if let Some(resp) = this.resp {
                                 let mut pair = StreamPair { stream, this };

src/runtime/webcore/Body.rs

@@ -1778,6 +1778,51 @@
         }
     }
 
+    /// Try to convert a still-unread blob/file-backed body stream back into a
+    /// Blob body value so consumers take the native blob paths (sendfile,
+    /// buffered reads) instead of the per-chunk JS streaming loop.
+    ///
+    /// `Value::to_blob_if_possible` can only consult the native
+    /// `Locked.readable` slot, but `check_body_stream_ref` migrates the stream
+    /// into the JS-side cache right after construction, leaving that slot
+    /// empty — so for `new Response(file.stream())` the conversion silently
+    /// never fires. Callers resolve the stream from either slot (via
+    /// `get_body_readable_stream`) and pass it in. Returns true when the body
+    /// value was replaced with the blob.
+    fn try_blob_from_resolved_stream(
+        &self,
+        global_object: &JSGlobalObject,
+        stream: &mut ReadableStream,
+    ) -> bool {
+        {
+            let Value::Locked(locked) = self.get_body_value() else {
+                return false;
+            };
+            // Someone is already consuming or waiting on this body.
+            if locked.promise.is_some()
+                || locked.on_receive_value.is_some()
+                || !locked.action.is_none()
+            {
+                return false;
+            }
+        }
+        // A reader the user holds must keep observing the stream; consumption
+        // must keep rejecting like the streaming path does.
+        if stream.is_locked(global_object) {
+            return false;
+        }
+        let Some(blob) = stream.to_any_blob(global_object) else {
+            return false;
+        };
+        self.detach_readable_stream(global_object);
+        *self.get_body_value() = match blob {
+            AnyBlob::Blob(b) => Value::Blob(b),
+            AnyBlob::InternalBlob(b) => Value::InternalBlob(b),
+            AnyBlob::WTFStringImpl(s) => Value::WTFStringImpl(s),
+        };
+        true
+    }
+
     /// Zig: `checkBodyStreamRef`. Migrate any `Locked.readable` strong ref
     /// into the GC-traced `js.gc.stream` slot to break the cycle (the JS
     /// wrapper owns the stream; native side must not hold it strongly).
@@ -1839,13 +1884,14 @@
         }
 
         if matches!(value, Value::Locked(_)) {
-            if let Some(readable) = self.get_body_readable_stream(global_object) {
+            if let Some(mut readable) = self.get_body_readable_stream(global_object) {
                 if readable.is_disturbed(global_object) {
                     return Ok(handle_body_already_used(global_object));
                 }
-                let value = self.get_body_value();
-                if let Value::Locked(locked) = value {
-                    return locked.set_promise(global_object, Action::GetText, Some(readable));
+                if !self.try_blob_from_resolved_stream(global_object, &mut readable) {
+                    if let Value::Locked(locked) = self.get_body_value() {
+                        return locked.set_promise(global_object, Action::GetText, Some(readable));
+                    }
                 }
             }
             let value = self.get_body_value();
@@ -1909,14 +1955,16 @@
         }
 
         if matches!(value, Value::Locked(_)) {
-            if let Some(readable) = self.get_body_readable_stream(global_object) {
+            if let Some(mut readable) = self.get_body_readable_stream(global_object) {
                 if readable.is_disturbed(global_object) {
                     return Ok(handle_body_already_used(global_object));
                 }
                 let value = self.get_body_value();
                 value.to_blob_if_possible();
-                if let Value::Locked(locked) = value {
-                    return locked.set_promise(global_object, Action::GetJSON, Some(readable));
+                if !self.try_blob_from_resolved_stream(global_object, &mut readable) {
+                    if let Value::Locked(locked) = self.get_body_value() {
+                        return locked.set_promise(global_object, Action::GetJSON, Some(readable));
+                    }
                 }
             }
             let value = self.get_body_value();
@@ -1956,18 +2004,20 @@
         }
 
         if matches!(value, Value::Locked(_)) {
-            if let Some(readable) = self.get_body_readable_stream(global_object) {
+            if let Some(mut readable) = self.get_body_readable_stream(global_object) {
                 if readable.is_disturbed(global_object) {
                     return Ok(handle_body_already_used(global_object));
                 }
                 let value = self.get_body_value();
                 value.to_blob_if_possible();
-                if let Value::Locked(locked) = value {
-                    return locked.set_promise(
-                        global_object,
-                        Action::GetArrayBuffer,
-                        Some(readable),
-                    );
+                if !self.try_blob_from_resolved_stream(global_object, &mut readable) {
+                    if let Value::Locked(locked) = self.get_body_value() {
+                        return locked.set_promise(
+                            global_object,
+                            Action::GetArrayBuffer,
+                            Some(readable),
+                        );
+                    }
                 }
             }
             let value = self.get_body_value();
@@ -2008,14 +2058,16 @@
         }
 
         if matches!(value, Value::Locked(_)) {
-            if let Some(readable) = self.get_body_readable_stream(global_object) {
+            if let Some(mut readable) = self.get_body_readable_stream(global_object) {
                 if readable.is_disturbed(global_object) {
                     return Ok(handle_body_already_used(global_object));
                 }
                 let value = self.get_body_value();
                 value.to_blob_if_possible();
-                if let Value::Locked(locked) = value {
-                    return locked.set_promise(global_object, Action::GetBytes, Some(readable));
+                if !self.try_blob_from_resolved_stream(global_object, &mut readable) {
+                    if let Value::Locked(locked) = self.get_body_value() {
+                        return locked.set_promise(global_object, Action::GetBytes, Some(readable));
+                    }
                 }
             }
             let value = self.get_body_value();
@@ -2149,7 +2201,7 @@
         }
 
         if matches!(value, Value::Locked(_)) {
-            if let Some(readable) = self.get_body_readable_stream(global_object) {
+            if let Some(mut readable) = self.get_body_readable_stream(global_object) {
                 let value = self.get_body_value();
                 let Value::Locked(locked) = value else {
                     unreachable!()
@@ -2161,8 +2213,10 @@
                     return Ok(handle_body_already_used(global_object));
                 }
                 value.to_blob_if_possible();
-                if let Value::Locked(locked) = value {
-                    return locked.set_promise(global_object, Action::GetBlob, Some(readable));
+                if !self.try_blob_from_resolved_stream(global_object, &mut readable) {
+                    if let Value::Locked(locked) = self.get_body_value() {
+                        return locked.set_promise(global_object, Action::GetBlob, Some(readable));
+                    }
                 }
             }
             let value = self.get_body_value();

src/runtime/webcore/ReadableStream.rs

@@ -196,6 +196,15 @@ impl ReadableStream {
                     // `store.clone()` carries the +1 that Zig's explicit `blob.store.?.ref()`
                     // provided after the raw-pointer copy in `initWithStore`.
                     let blob = Blob::init_with_store(store.clone(), global_this);
+                    // Restore the slice window the FileReader carries (the inverse
+                    // of `from_blob_copy_ref`); `init_with_store` spans the whole
+                    // store, which would serve the entire file for a sliced blob.
+                    if let Some(offset) = blobby.start_offset {
+                        blob.offset.set(offset as webcore::blob::SizeType);
+                    }
+                    if let Some(max_size) = blobby.max_size {
+                        blob.size.set(max_size as webcore::blob::SizeType);
+                    }
                     // it should be lazy, file shouldn't have opened yet.
                     debug_assert!(!blobby.started.get());
                     self.done(global_this);

test/js/bun/http/serve.test.ts

@@ -2396,3 +2396,88 @@ it.if(isPosix)("serves /bun:info over a unix socket in development mode", async
   expect(text).toContain("bun_version");
   expect(res.status).toBe(200);
 });
+
+describe("Response wrapping a Bun.file() stream", () => {
+  // Position-dependent contents so slice windows are verifiable. 1 MiB: on
+  // unfixed builds, serving a sliced file stream stalls until idleTimeout
+  // and resets the connection (the test then fails by timeout).
+  const STREAM_FILE_SIZE = 1024 * 1024;
+  function makeStreamFile() {
+    const bytes = new Uint8Array(STREAM_FILE_SIZE);
+    for (let i = 0; i < STREAM_FILE_SIZE; i++) bytes[i] = (i * 7) & 0xff;
+    const dir = tmpdirSync();
+    const path = join(dir, "serve-file-stream.bin");
+    writeFileSync(path, bytes);
+    return { path, bytes };
+  }
+
+  it("serves with Content-Length via the native blob path", async () => {
+    const { path, bytes } = makeStreamFile();
+    using server = Bun.serve({
+      port: 0,
+      fetch: () => new Response(file(path).stream()),
+    });
+
+    const res = await fetch(server.url);
+    // an unread file-backed stream takes the same path as Response(file):
+    // sized body, no chunked encoding
+    expect(res.headers.get("content-length")).toBe(String(STREAM_FILE_SIZE));
+    expect(res.headers.get("transfer-encoding")).toBeNull();
+    const body = await res.bytes();
+    expect(body.byteLength).toBe(STREAM_FILE_SIZE);
+    expect(Buffer.compare(body, bytes)).toBe(0);
+  });
+
+  it("serves a sliced file stream with exactly the slice's bytes", async () => {
+    const { path, bytes } = makeStreamFile();
+    const start = 100;
+    const end = 1124;
+    using server = Bun.serve({
+      port: 0,
+      idleTimeout: 5,
+      fetch: () => new Response(file(path).slice(start, end).stream()),
+    });
+
+    const res = await fetch(server.url);
+    const body = await res.bytes();
+    expect(body.byteLength).toBe(end - start);
+    expect(Buffer.compare(body, bytes.subarray(start, end))).toBe(0);
+    expect(res.headers.get("content-length")).toBe(String(end - start));
+  });
+
+  it("a stream being read by user JS keeps the streaming error semantics", async () => {
+    // The locked-stream error is reported as an unhandled error after the
+    // headers are sent, so this case runs in a subprocess.
+    const { path } = makeStreamFile();
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `
+        using server = Bun.serve({
+          port: 0,
+          fetch: () => {
+            // lock the stream after constructing the Response: the render
+            // path must not bypass the existing cannot-pipe error handling
+            const response = new Response(Bun.file(${JSON.stringify(path)}).stream());
+            response.body.getReader();
+            return response;
+          },
+        });
+        const res = await fetch(server.url);
+        const body = await res.text();
+        console.log("status:" + res.status + " body-bytes:" + body.length);
+        `,
+      ],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    // headers go out, then the locked stream errors and the body is
+    // truncated; the unhandled error exits the process with 1
+    expect(stdout).toContain("status:200 body-bytes:0");
+    expect(stderr).toContain("ReadableStream is locked");
+    expect(exitCode).toBe(1);
+  });
+});

test/js/web/fetch/body.test.ts

@@ -736,3 +736,84 @@
     });
   }
 });
+
+describe("Response wrapping a Bun.file() stream", () => {
+  // Position-dependent content so slice windows are verifiable. 1 MiB:
+  // on unfixed builds, consuming a Response wrapping a sliced stream of a
+  // file this large never resolves (the test then fails by timeout).
+  const SIZE = 1024 * 1024;
+  function makeFile(dir: string) {
+    const bytes = new Uint8Array(SIZE);
+    for (let i = 0; i < SIZE; i++) bytes[i] = (i * 7) & 0xff;
+    const path = `${dir}/body-file-stream.bin`;
+    require("fs").writeFileSync(path, bytes);
+    return { path, bytes };
+  }
+
+  test(".bytes() returns a Uint8Array with the full contents", async () => {
+    const { tempDirWithFiles } = require("harness");
+    const dir = tempDirWithFiles("body-file-stream", {});
+    const { path, bytes } = makeFile(dir);
+
+    const result = await new Response(file(path).stream()).bytes();
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result.byteLength).toBe(SIZE);
+    expect(Buffer.compare(result, bytes)).toBe(0);
+  });
+
+  test(".bytes() on a sliced file stream resolves with exactly the slice", async () => {
+    const { tempDirWithFiles } = require("harness");
+    const dir = tempDirWithFiles("body-file-stream-slice", {});
+    const { path, bytes } = makeFile(dir);
+
+    const start = 100;
+    const end = 1124;
+    const result = await new Response(file(path).slice(start, end).stream()).bytes();
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result.byteLength).toBe(end - start);
+    expect(Buffer.compare(result, bytes.subarray(start, end))).toBe(0);
+  });
+
+  test(".text() and .arrayBuffer() on a sliced file stream resolve", async () => {
+    const { tempDirWithFiles } = require("harness");
+    const dir = tempDirWithFiles("body-file-stream-text", {});
+    const path = `${dir}/text.txt`;
+    require("fs").writeFileSync(path, "0123456789".repeat(100));
+
+    const text = await new Response(file(path).slice(10, 30).stream()).text();
+    expect(text).toBe("01234567890123456789");
+
+    const ab = await new Response(file(path).slice(10, 30).stream()).arrayBuffer();
+    expect(ab.byteLength).toBe(20);
+  });
+
+  test("a disturbed file stream still throws at Response construction", async () => {
+    const { tempDirWithFiles } = require("harness");
+    const dir = tempDirWithFiles("body-file-stream-read", {});
+    const { path } = makeFile(dir);
+
+    const stream = file(path).stream();
+    const reader = stream.getReader();
+    const first = await reader.read();
+    expect(first.done).toBe(false);
+    reader.releaseLock();
+
+    expect(() => new Response(stream)).toThrow("ReadableStream has already been used");
+  });
+
+  test("a file stream with a held reader keeps rejecting consumption", async () => {
+    const { tempDirWithFiles } = require("harness");
+    const dir = tempDirWithFiles("body-file-stream-locked", {});
+    const { path } = makeFile(dir);
+
+    const response = new Response(file(path).stream());
+    const reader = response.body!.getReader();
+    expect(response.body!.locked).toBe(true);
+    // the held reader must keep observing the stream; bytes() must not
+    // short-circuit to the blob path
+    expect(async () => {
+      await response.bytes();
+    }).toThrow();
+    reader.releaseLock();
+  });
+});