Improve synchronous writes for stdio file descriptors

src/bun.js/api/bun/socket.zig

@@ -1432,7 +1432,8 @@ fn NewSocket(comptime ssl: bool) type {
             owned_protos: bool = true,
             is_paused: bool = false,
             allow_half_open: bool = false,
-            _: u7 = 0,
+            is_stdio_fd: bool = false,
+            _: u6 = 0,
         };
 
         pub fn hasPendingActivity(this: *This) callconv(.C) bool {
@@ -1492,6 +1493,15 @@ fn NewSocket(comptime ssl: bool) type {
                 },
                 .fd => |f| {
                     const socket = This.Socket.fromFd(this.socket_context.?, f, This, this, null, false) orelse return error.ConnectionFailed;
+
+                    // For stdout/stderr file descriptors, ensure synchronous writes
+                    const fd_int = f.cast();
+                    if (fd_int == 1 or fd_int == 2) {
+                        this.flags.is_stdio_fd = true;
+                        // Mark the underlying file descriptor as blocking for synchronous writes
+                        _ = bun.sys.updateNonblocking(f, false);
+                    }
+
                     this.onOpen(socket);
                 },
             }
@@ -2211,6 +2221,20 @@ fn NewSocket(comptime ssl: bool) type {
                 return -1;
             }
 
+            // For stdio file descriptors, always write with flush
+            if (this.flags.is_stdio_fd) {
+                // Write with force flush for immediate output
+                const res = this.socket.write(buffer, true);
+                const uwrote: usize = @intCast(@max(res, 0));
+                this.bytes_written += uwrote;
+                log("write({d}) = {d} (stdio fd)", .{ buffer.len, res });
+
+                // Also explicitly flush the socket
+                this.socket.flush();
+
+                return res;
+            }
+
             // we don't cork yet but we might later
             if (comptime ssl) {
                 // TLS wrapped but in TCP mode

src/bun.js/bindings/webcore/HTTPHeaderMap.cpp

@@ -40,7 +40,7 @@ static StringView extractCookieName(const StringView& cookie)
 {
     auto nameEnd = cookie.find('=');
     if (nameEnd == notFound)
-        return String();
+        return StringView();
     return cookie.substring(0, nameEnd);
 }
 

src/bun.js/webcore/FileSink.zig

@@ -487,7 +487,14 @@ pub fn write(this: *@This(), data: streams.Result) streams.Result.Writable {
         return .{ .done = {} };
     }
 
-    return this.toResult(this.writer.write(data.slice()));
+    const result = this.toResult(this.writer.write(data.slice()));
+
+    // For synchronous file descriptors (like stderr), ensure data is fully written
+    if (this.force_sync and this.writer.hasPendingData()) {
+        _ = this.writer.flush();
+    }
+
+    return result;
 }
 pub const writeBytes = write;
 pub fn writeLatin1(this: *@This(), data: streams.Result) streams.Result.Writable {
@@ -495,14 +502,28 @@ pub fn writeLatin1(this: *@This(), data: streams.Result) streams.Result.Writable
         return .{ .done = {} };
     }
 
-    return this.toResult(this.writer.writeLatin1(data.slice()));
+    const result = this.toResult(this.writer.writeLatin1(data.slice()));
+
+    // For synchronous file descriptors (like stderr), ensure data is fully written
+    if (this.force_sync and this.writer.hasPendingData()) {
+        _ = this.writer.flush();
+    }
+
+    return result;
 }
 pub fn writeUTF16(this: *@This(), data: streams.Result) streams.Result.Writable {
     if (this.done) {
         return .{ .done = {} };
     }
 
-    return this.toResult(this.writer.writeUTF16(data.slice16()));
+    const result = this.toResult(this.writer.writeUTF16(data.slice16()));
+
+    // For synchronous file descriptors (like stderr), ensure data is fully written
+    if (this.force_sync and this.writer.hasPendingData()) {
+        _ = this.writer.flush();
+    }
+
+    return result;
 }
 
 pub fn end(this: *FileSink, _: ?bun.sys.Error) JSC.Maybe(void) {

test/js/node/test/sequential/test-stream2-stderr-sync.js

@@ -0,0 +1,95 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Make sure that sync writes to stderr get processed before exiting.
+
+require('../common');
+
+function parent() {
+  const spawn = require('child_process').spawn;
+  const assert = require('assert');
+  let i = 0;
+  children.forEach(function(_, c) {
+    const child = spawn(process.execPath, [__filename, String(c)]);
+    let err = '';
+
+    child.stderr.on('data', function(c) {
+      err += c;
+    });
+
+    child.on('close', function() {
+      assert.strictEqual(err, `child ${c}\nfoo\nbar\nbaz\n`);
+      console.log(`ok ${++i} child #${c}`);
+      if (i === children.length)
+        console.log(`1..${i}`);
+    });
+  });
+}
+
+// using console.error
+function child0() {
+  console.error('child 0');
+  console.error('foo');
+  console.error('bar');
+  console.error('baz');
+}
+
+// Using process.stderr
+function child1() {
+  process.stderr.write('child 1\n');
+  process.stderr.write('foo\n');
+  process.stderr.write('bar\n');
+  process.stderr.write('baz\n');
+}
+
+// using a net socket
+function child2() {
+  const net = require('net');
+  const socket = new net.Socket({
+    fd: 2,
+    readable: false,
+    writable: true,
+  });
+  socket.write('child 2\n');
+  socket.write('foo\n');
+  socket.write('bar\n');
+  socket.write('baz\n');
+}
+
+
+function child3() {
+  console.error('child 3\nfoo\nbar\nbaz');
+}
+
+function child4() {
+  process.stderr.write('child 4\nfoo\nbar\nbaz\n');
+}
+
+const children = [ child0, child1, child2, child3, child4 ];
+
+if (!process.argv[2]) {
+  parent();
+} else {
+  children[process.argv[2]]();
+  // Immediate process.exit to kill any waiting stuff.
+  process.exit();
+}