process.stdout/stderr with no FileSink: write synchronously, reset after a failed write

src/js/builtins/ProcessObjectInternals.ts

@@ -91,7 +91,32 @@ export function getStdioWriteStream(
   stream.fd = fd;
 
   const underlyingSink = stream[require("internal/fs/streams").kWriteStreamFastPath];
-  $assert(underlyingSink);
+  if (!underlyingSink && !stream._writableState.autoDestroy) {
+    // No FileSink: Writable parks every write after a failed one until destroy, so a failed write resets the stream.
+    const failures: unknown[] = []; // in order: a corked batch fails one write per chunk
+    const write = stream._write;
+    const destroy = stream._destroy;
+    stream._write = function (chunk, encoding, cb) {
+      write.$call(this, chunk, encoding, err => {
+        if (err) {
+          failures.push(err);
+          this._writableState.autoDestroy = true;
+        }
+        cb(err);
+      });
+    };
+    stream._destroy = function (err, cb) {
+      if (!err || err !== failures[0]) return destroy.$call(this, err, cb);
+      failures.shift();
+      if (failures.length === 0) this._writableState.autoDestroy = false;
+      this._undestroy();
+      // Not through cb: that marks the reset stream errorEmitted a tick later, and end() then never finishes.
+      process.nextTick(() => {
+        this.emit("error", err);
+        this.emit("close");
+      });
+    };
+  }
   return [stream, underlyingSink];
 }
 

src/js/internal/fs/streams.ts

@@ -2,7 +2,7 @@
 import type { FileSink } from "bun";
 const { Readable, Writable, finished } = require("node:stream");
 const fs = require("node:fs");
-const { read, write, fsync, writev } = fs;
+const { read, write, writeSync, fsync, writev } = fs;
 const { FileHandle, kRef, kUnref, kFd } = (fs.promises as any).$data as {
   FileHandle: { new (): FileHandle };
   readonly kRef: unique symbol;
@@ -457,17 +457,17 @@ function WriteStream(this: FSStream, path: string | null | undefined, options?:
     this.pos = start;
   }
 
-  // A writer cannot be opened for every fd a caller may hand us -- a read-only
-  // descriptor is the common case, and node's tty.WriteStream accepts one. Fall
-  // back to the general path there, which surfaces the failure at write time the
-  // way node does, rather than throwing from the constructor.
+  // No writer for this fd (fd limit, macOS /dev/tty): write synchronously, so a bad fd fails at write time as in node.
   let fastWriter;
   if (fastPath && fd != null) {
     try {
       fastWriter = Bun.file(fd).writer();
     } catch {
       fastPath = false;
+      this._write = underscoreWriteSync;
     }
+    // Already-open fd (stdio): born constructed, like node's stdio streams, which allocate no construct TickObjects.
+    this._construct = undefined;
   }
 
   // Enable fast path
@@ -477,12 +477,6 @@ function WriteStream(this: FSStream, path: string | null | undefined, options?:
     this._writev = undefined;
     this.write = writeFast as any;
     this._final = finalFast;
-    if (fd != null) {
-      // Already-open fd (stdio): skip the async _construct round-trip so the
-      // stream is born constructed, like node's stdio streams (net.Socket /
-      // tty.WriteStream), which never allocate construct TickObjects.
-      this._construct = undefined;
-    }
   }
 
   Writable.$call(this, options);
@@ -602,6 +596,29 @@ function _write(data, encoding, cb) {
 }
 writeStreamPrototype._write = _write;
 
+function underscoreWriteSync(this: FSStream, data: Buffer, encoding: any, cb: (err?: any) => void) {
+  const length = data.length;
+  let offset = 0;
+  let retries = 0;
+  while (offset < length) {
+    let written: number;
+    try {
+      written = writeSync(this.fd, data, offset, length - offset);
+    } catch (err: any) {
+      if (err?.code !== "EAGAIN") return cb(err);
+      // A non-blocking fd with no room: wait for the reader, as a blocking write would.
+      Bun.sleepSync(1);
+      continue;
+    }
+    // Like writeAll: an fd that takes no bytes several times in a row fails the write.
+    if (written > 0) retries = 0;
+    else if (++retries > 5) return cb(new Error("write failed"));
+    this.bytesWritten += written;
+    offset += written;
+  }
+  cb(null);
+}
+
 function underscoreWriteFast(this: FSStream, data: any, encoding: any, cb: any) {
   let fileSink = this[kWriteStreamFastPath];
   if (!fileSink) {