Fix server stability issue with oversized requests

Improves request handling for edge cases.

Fixes #22353

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: Claude Bot

src/bun.js/api/server.zig

@@ -2221,9 +2221,11 @@ pub fn NewServer(protocol_enum: enum { http, https }, development_kind: enum { d
                 };
 
                 if (req_len > this.config.max_request_body_size) {
+                    // Set up abort handler before ending the response to ensure proper cleanup
+                    ctx.setAbortHandler();
                     resp.writeStatus("413 Request Entity Too Large");
                     resp.endWithoutBody(true);
-                    this.finalize();
+                    // Don't call finalize() here - let the abort handler clean up
                     return null;
                 }
 

test/regression/issue/22353.test.ts

@@ -0,0 +1,111 @@
+import { test, expect } from "bun:test";
+import { bunEnv, bunExe, tempDir, normalizeBunSnapshot } from "harness";
+
+test("issue #22353 - server handles oversized requests correctly", async () => {
+  using dir = tempDir("oversized-request", {
+    "server.ts": `
+      const server = Bun.serve({
+        port: 0,
+        maxRequestBodySize: 1024, // 1KB limit
+        async fetch(req) {
+          console.log("Processing request");
+          const body = await req.text();
+          return new Response(JSON.stringify({
+            received: true,
+            size: body.length
+          }), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      });
+
+      console.log(JSON.stringify({ port: server.port }));
+      console.error("Server started");
+    `,
+  });
+
+  // Start server
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "server.ts"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  // Get port from server output
+  const reader = proc.stdout.getReader();
+  const { value } = await reader.read();
+  const decoder = new TextDecoder();
+  const portLine = decoder.decode(value);
+  const portJson = portLine.split('\n')[0]; // Get just the first line with the port
+  const { port } = JSON.parse(portJson.trim());
+  reader.releaseLock();
+
+  expect(port).toBeGreaterThan(0);
+
+  // Send request larger than limit (2KB)
+  const largeBody = "x".repeat(2048);
+
+  let largeResponse;
+  try {
+    largeResponse = await fetch(`http://localhost:${port}`, {
+      method: "POST",
+      body: largeBody,
+    });
+  } catch (e) {
+    // Server may reject with 413 or close connection
+  }
+
+  // Small delay to ensure server processes the rejection
+  await Bun.sleep(100);
+
+  // Send normal request - server should still be working
+  const normalResponse = await fetch(`http://localhost:${port}`, {
+    method: "POST",
+    body: JSON.stringify({ test: "normal" }),
+  });
+
+  expect(normalResponse.ok).toBe(true);
+  const json = await normalResponse.json();
+  expect(json.received).toBe(true);
+  expect(json.size).toBe(17);
+
+  // Kill server gracefully
+  proc.kill();
+
+  // Collect remaining output
+  let remainingStdout = "";
+  let remainingStderr = "";
+
+  try {
+    const stdoutReader = proc.stdout.getReader();
+    while (true) {
+      const { done, value } = await stdoutReader.read();
+      if (done) break;
+      remainingStdout += decoder.decode(value);
+    }
+    stdoutReader.releaseLock();
+  } catch {}
+
+  try {
+    const stderrReader = proc.stderr.getReader();
+    while (true) {
+      const { done, value } = await stderrReader.read();
+      if (done) break;
+      remainingStderr += decoder.decode(value);
+    }
+    stderrReader.releaseLock();
+  } catch {}
+
+  const exitCode = await proc.exited;
+
+  // Server should exit cleanly with SIGTERM
+  expect(exitCode).toBe(143); // 128 + 15 (SIGTERM)
+
+  // Verify stdout contains expected output
+  expect(remainingStdout).toContain("Processing request");
+
+  // Verify stderr
+  expect(normalizeBunSnapshot(remainingStderr, dir)).toMatchInlineSnapshot(`"Server started"`);
+}, 10000);