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

src/runtime/server/RequestContext.rs

@@ -2401,6 +2401,15 @@
         // not content-length or transfer-encoding so we need to respect the body
         let body_value = response.get_body_value();
         body_value.to_blob_if_possible();
+        // `to_blob_if_possible` can't see streams migrated into the JS-side
+        // cached slot; convert blob/file-backed streams here too so HEAD
+        // reports the same Content-Length the GET render path produces.
+        if matches!(body_value, Body::Value::Locked(_)) {
+            if let Some(mut readable) = response.get_body_readable_stream(global_this) {
+                let _ = response.try_blob_from_resolved_stream(global_this, &mut readable);
+            }
+        }
+        let body_value = response.get_body_value();
         match body_value {
             Body::Value::InternalBlob(_) | Body::Value::WTFStringImpl(_) => {
                 let mut blob = body_value.use_as_any_blob_allow_non_utf8_string();
@@ -2909,11 +2918,29 @@
                             return;
                         }
                         // 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::Blob(_) | 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::Direct => {
+                        readable_stream::Source::JavaScript | readable_stream::Source::Direct => {
                             if let Some(resp) = this.resp {
                                 let mut pair = StreamPair { stream, this };
                                 resp.run_corked_with_type(Self::do_render_stream, &raw mut pair);
@@ -2942,9 +2969,8 @@
                             // we can avoid streaming it and just send it all at once.
                             if byte_stream.has_received_last_chunk.get() {
                                 let mut byte_list = byte_stream.drain();
-                                this.blob = AnyBlob::from_array_list(
-                                    byte_list.move_to_list_managed(),
-                                );
+                                this.blob =
+                                    AnyBlob::from_array_list(byte_list.move_to_list_managed());
                                 this.response_body_readable_stream_ref.deinit();
                                 this.do_render_blob();
                                 return;

src/runtime/webcore/Body.rs

@@ -1778,6 +1778,51 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
     }
 
+    /// 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 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         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,14 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         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 +2002,18 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         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 +2054,14 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         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();
@@ -2091,6 +2137,12 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
 
         let value = self.get_body_value();
         if let Value::Locked(_locked) = value {
+            // Unlike the other consumers, this one must NOT take
+            // `try_blob_from_resolved_stream`: the parse below reads
+            // `blob.slice()` synchronously, and a converted file-backed blob
+            // has no in-memory bytes yet — there is no async
+            // file-read-then-parse path here (same in the Zig original, where
+            // `Response(Bun.file(p)).formData()` has the same limitation).
             let owned_readable = self.get_body_readable_stream(global_object);
             // PORT NOTE: reshaped for borrowck — re-borrow after self method call.
             let value = self.get_body_value();
@@ -2149,7 +2201,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         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!()
@@ -2160,9 +2212,10 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
                 {
                     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();
@@ -2519,9 +2572,27 @@ impl<'a> ValueBufferer<'a> {
                 webcore::readable_stream::Source::Invalid => {
                     return Err(bun_core::err!("InvalidStream"));
                 }
-                // toBlobIfPossible should've caught this
                 webcore::readable_stream::Source::Blob(_)
-                | webcore::readable_stream::Source::File(_) => unreachable!(),
+                | webcore::readable_stream::Source::File(_) => {
+                    // `run`'s `to_blob_if_possible` only consults the native
+                    // `Locked.readable` slot, so blob/file-backed streams that
+                    // `check_body_stream_ref` migrated into the JS-side cache
+                    // land here. Convert them now and re-dispatch through the
+                    // Blob arm (buffered bytes / async file read).
+                    let mut stream = stream;
+                    if let Some(blob) = stream.to_any_blob(self.global) {
+                        *value = match blob {
+                            AnyBlob::Blob(b) => Value::Blob(b),
+                            AnyBlob::InternalBlob(b) => Value::InternalBlob(b),
+                            AnyBlob::WTFStringImpl(s) => Value::WTFStringImpl(s),
+                        };
+                        // the stream's source is consumed and detached; no
+                        // reason to keep the JS wrapper rooted
+                        let _ = core::mem::take(&mut self.readable_stream_ref);
+                        return self.run(value, None);
+                    }
+                    return Err(bun_core::err!("UnsupportedStreamType"));
+                }
                 webcore::readable_stream::Source::JavaScript
                 | webcore::readable_stream::Source::Direct => {
                     // this is broken right now

src/runtime/webcore/ReadableStream.rs

@@ -196,9 +196,25 @@ 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);
+                    // The FileReader keeps its lazy store (the blob above only
+                    // clones it), so without this a captured stream reference
+                    // could be wrapped into a new Response and re-read the
+                    // file from disk. Mark the JS stream disturbed and drop
+                    // its native ptr — the exact state the JS streaming path
+                    // used to leave a consumed file stream in.
+                    self.force_detach(global_this);
                     return Some(webcore::blob::Any::Blob(blob));
                 }
             }

src/runtime/webcore/Response.rs

@@ -473,6 +473,15 @@ impl Response {
         <Self as BodyMixin>::detach_readable_stream(self, global_object)
     }
 
+    #[inline]
+    pub fn try_blob_from_resolved_stream(
+        &self,
+        global_object: &JSGlobalObject,
+        stream: &mut super::readable_stream::ReadableStream,
+    ) -> bool {
+        <Self as BodyMixin>::try_blob_from_resolved_stream(self, global_object, stream)
+    }
+
     #[inline]
     pub fn set_size_hint(&self, size_hint: super::blob::SizeType) {
         if let BodyValue::Locked(locked) = self.body.get().value_mut() {