[autofix.ci] apply automated fixes

When `ServerResponse.end()` is called without an underlying socket/handle
(e.g., when using `light-my-request` for testing), the early-return path
was not setting `this.finished = true`, causing `writableEnded` to
incorrectly return `false`. This broke Fastify compatibility with
light-my-request for testing scenarios.

The fix adds the same lifecycle handling in the no-handle code path:
- Sets `this.finished = true`
- Emits "prefinish" and "finish" events
- Calls the callback if provided
- Emits "close" event via nextTick

Fixes #25632

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/bun.js/webcore/Request.zig

@@ -1089,8 +1089,8 @@ const string = []const u8;
 
 const Environment = @import("../../env.zig");
 const std = @import("std");
-const FetchRedirect = @import("../../http/FetchRedirect.zig").FetchRedirect;
 const FetchCacheMode = @import("../../http/FetchCacheMode.zig").FetchCacheMode;
+const FetchRedirect = @import("../../http/FetchRedirect.zig").FetchRedirect;
 const FetchRequestMode = @import("../../http/FetchRequestMode.zig").FetchRequestMode;
 const Method = @import("../../http/Method.zig").Method;
 

src/js/node/_http_server.ts

@@ -1335,8 +1335,32 @@ ServerResponse.prototype.end = function (chunk, encoding, callback) {
   }
 
   if (!handle) {
-    if ($isCallable(callback)) {
-      process.nextTick(callback);
+    this.finished = true;
+    process.nextTick(self => {
+      self._ended = true;
+    }, this);
+    this.emit("prefinish");
+    this._callPendingCallbacks();
+
+    if (callback) {
+      process.nextTick(
+        function (callback, self) {
+          self.emit("finish");
+          try {
+            callback();
+          } catch (err) {
+            self.emit("error", err);
+          }
+          process.nextTick(emitCloseNT, self);
+        },
+        callback,
+        this,
+      );
+    } else {
+      process.nextTick(function (self) {
+        self.emit("finish");
+        process.nextTick(emitCloseNT, self);
+      }, this);
     }
     return this;
   }

test/regression/issue/25632.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from "bun:test";
+import http from "node:http";
+
+test("ServerResponse.writableEnded should be true after end() when no socket", () => {
+  const req = new http.IncomingMessage(null);
+  const res = new http.ServerResponse(req);
+
+  expect(res.finished).toBe(false);
+  expect(res.writableEnded).toBe(false);
+
+  res.end();
+
+  expect(res.finished).toBe(true);
+  expect(res.writableEnded).toBe(true);
+});
+
+test("ServerResponse.writableEnded should be true after end() with callback when no socket", async () => {
+  const req = new http.IncomingMessage(null);
+  const res = new http.ServerResponse(req);
+
+  expect(res.finished).toBe(false);
+  expect(res.writableEnded).toBe(false);
+
+  let callbackCalled = false;
+  res.end(() => {
+    callbackCalled = true;
+  });
+
+  expect(res.finished).toBe(true);
+  expect(res.writableEnded).toBe(true);
+
+  // Wait for the callback to be called via process.nextTick
+  await new Promise(resolve => process.nextTick(resolve));
+  expect(callbackCalled).toBe(true);
+});
+
+test("ServerResponse.writableEnded should be true after end() with chunk when no socket", () => {
+  const req = new http.IncomingMessage(null);
+  const res = new http.ServerResponse(req);
+
+  expect(res.finished).toBe(false);
+  expect(res.writableEnded).toBe(false);
+
+  res.end("test");
+
+  expect(res.finished).toBe(true);
+  expect(res.writableEnded).toBe(true);
+});