From 59f1e9f08f266d48da98c5e850a02028cafcf28f Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 20:59:42 -0400
Subject: [PATCH 01/19] fix(stdio): add stdin close/end listeners to prevent
 zombie processes

When an MCP client (e.g. Claude Code) closes its end of the stdin pipe,
StdioServerTransport does not detect the disconnect and the server
process lingers indefinitely as a zombie/orphan.

This adds belt-and-suspenders `process.stdin` close/end listeners
immediately after `session.connect(transport)` for the stdio transport
path. When either event fires, `transport.close()` is called so the
process exits cleanly.

The upstream SDK is tracking the same root cause in
modelcontextprotocol/typescript-sdk#2003. Adding the fix here means
FastMCP users are protected regardless of which SDK version they have
installed.
---
 src/FastMCP.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/FastMCP.ts b/src/FastMCP.ts
index d193d5d..10e0c10 100644
--- a/src/FastMCP.ts
+++ b/src/FastMCP.ts
@@ -2620,6 +2620,15 @@ export class FastMCP<
 
       await session.connect(transport);
 
+      // Belt-and-suspenders: detect when the MCP client closes its end of
+      // the stdin pipe and shut down the transport so the process doesn't
+      // linger as a zombie/orphan. The upstream SDK fix (PR #2003) handles
+      // this inside StdioServerTransport itself, but adding the listener here
+      // means older SDK versions are also protected.
+      const onStdinClose = () => { transport.close().catch(() => {}); };
+      process.stdin.on("close", onStdinClose);
+      process.stdin.on("end", onStdinClose);
+
       this.#sessions.push(session);
 
       session.once("error", () => {

From a7dc3bbfc6116e405df7552f76fec13e4025f587 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:04:49 -0400
Subject: [PATCH 02/19] style: run prettier on FastMCP.ts

---
 src/FastMCP.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/FastMCP.ts b/src/FastMCP.ts
index 10e0c10..e7ccdce 100644
--- a/src/FastMCP.ts
+++ b/src/FastMCP.ts
@@ -2625,7 +2625,9 @@ export class FastMCP<
       // linger as a zombie/orphan. The upstream SDK fix (PR #2003) handles
       // this inside StdioServerTransport itself, but adding the listener here
       // means older SDK versions are also protected.
-      const onStdinClose = () => { transport.close().catch(() => {}); };
+      const onStdinClose = () => {
+        transport.close().catch(() => {});
+      };
       process.stdin.on("close", onStdinClose);
       process.stdin.on("end", onStdinClose);
 

From 27e5d4b09e562ab2afc75c1073a85a0ff707ee94 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:11:47 -0400
Subject: [PATCH 03/19] =?UTF-8?q?fix:=20address=20Copilot=20review=20?=
 =?UTF-8?q?=E2=80=94=20idempotency,=20listener=20cleanup,=20and=20stdio=20?=
 =?UTF-8?q?test?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add stdinClosed guard to prevent double-close race when both close
  and end fire for the same shutdown
- Remove stdin listeners inside the handler (on first fire) and also in
  transport.onclose to prevent listener accumulation across start() calls
- Add src/FastMCP.stdio.test.ts with vitest tests verifying registration,
  single-fire idempotency, and listener removal

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/FastMCP.stdio.test.ts | 153 ++++++++++++++++++++++++++++++++++++++
 src/FastMCP.ts            |   9 +++
 2 files changed, 162 insertions(+)
 create mode 100644 src/FastMCP.stdio.test.ts

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
new file mode 100644
index 0000000..3646ca4
--- /dev/null
+++ b/src/FastMCP.stdio.test.ts
@@ -0,0 +1,153 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { FastMCP } from "./FastMCP.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Minimal fake transport that satisfies what FastMCP needs for stdio. */
+function makeFakeTransport() {
+  const transport = {
+    close: vi.fn().mockResolvedValue(undefined),
+    onclose: undefined as (() => void) | undefined,
+    // FastMCPSession.connect() calls start() on the transport
+    start: vi.fn().mockResolvedValue(undefined),
+    // The SDK Server calls these
+    send: vi.fn().mockResolvedValue(undefined),
+    onerror: undefined as ((e: Error) => void) | undefined,
+    onmessage: undefined as ((msg: unknown) => void) | undefined,
+  };
+  return transport;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("stdio stdin listener lifecycle", () => {
+  let stdinOnSpy: ReturnType<typeof vi.spyOn>;
+  let stdinOffSpy: ReturnType<typeof vi.spyOn>;
+  let stdinListeners: Map<string, (...args: unknown[]) => void>;
+
+  beforeEach(() => {
+    stdinListeners = new Map();
+
+    stdinOnSpy = vi
+      .spyOn(process.stdin, "on")
+      .mockImplementation(
+        (event: string, listener: (...args: unknown[]) => void) => {
+          stdinListeners.set(event, listener);
+          return process.stdin;
+        },
+      );
+
+    stdinOffSpy = vi
+      .spyOn(process.stdin, "off")
+      .mockImplementation(
+        (_event: string, _listener: (...args: unknown[]) => void) => {
+          return process.stdin;
+        },
+      );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("registers 'close' and 'end' listeners after start({ transportType: 'stdio' })", async () => {
+    const fakeTransport = makeFakeTransport();
+
+    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+      StdioServerTransport: vi.fn(() => fakeTransport),
+    }));
+
+    const server = new FastMCP({ name: "Test", version: "1.0.0" });
+
+    // We don't await start() because stdio transport normally runs forever;
+    // we just need to verify the listeners were registered.
+    const startPromise = server
+      .start({ transportType: "stdio" })
+      .catch(() => {});
+
+    // Give the microtask queue a turn so the synchronous listener registration runs
+    await Promise.resolve();
+
+    expect(stdinOnSpy).toHaveBeenCalledWith("close", expect.any(Function));
+    expect(stdinOnSpy).toHaveBeenCalledWith("end", expect.any(Function));
+
+    await startPromise;
+  });
+
+  it("calls transport.close() exactly once when 'close' fires", async () => {
+    const fakeTransport = makeFakeTransport();
+
+    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+      StdioServerTransport: vi.fn(() => fakeTransport),
+    }));
+
+    const server = new FastMCP({ name: "Test", version: "1.0.0" });
+    const startPromise = server
+      .start({ transportType: "stdio" })
+      .catch(() => {});
+    await Promise.resolve();
+
+    const closeListener = stdinListeners.get("close");
+    expect(closeListener).toBeDefined();
+    closeListener!();
+
+    expect(fakeTransport.close).toHaveBeenCalledTimes(1);
+
+    await startPromise;
+  });
+
+  it("does NOT call transport.close() a second time when 'end' fires after 'close' (idempotency)", async () => {
+    const fakeTransport = makeFakeTransport();
+
+    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+      StdioServerTransport: vi.fn(() => fakeTransport),
+    }));
+
+    const server = new FastMCP({ name: "Test", version: "1.0.0" });
+    const startPromise = server
+      .start({ transportType: "stdio" })
+      .catch(() => {});
+    await Promise.resolve();
+
+    const closeListener = stdinListeners.get("close");
+    const endListener = stdinListeners.get("end");
+    expect(closeListener).toBeDefined();
+    expect(endListener).toBeDefined();
+
+    // Fire 'close' first, then 'end' — transport.close should only be called once
+    closeListener!();
+    endListener!();
+
+    expect(fakeTransport.close).toHaveBeenCalledTimes(1);
+
+    await startPromise;
+  });
+
+  it("removes both listeners after the handler fires", async () => {
+    const fakeTransport = makeFakeTransport();
+
+    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+      StdioServerTransport: vi.fn(() => fakeTransport),
+    }));
+
+    const server = new FastMCP({ name: "Test", version: "1.0.0" });
+    const startPromise = server
+      .start({ transportType: "stdio" })
+      .catch(() => {});
+    await Promise.resolve();
+
+    const closeListener = stdinListeners.get("close");
+    expect(closeListener).toBeDefined();
+    closeListener!();
+
+    expect(stdinOffSpy).toHaveBeenCalledWith("close", closeListener);
+    expect(stdinOffSpy).toHaveBeenCalledWith("end", closeListener);
+
+    await startPromise;
+  });
+});
diff --git a/src/FastMCP.ts b/src/FastMCP.ts
index e7ccdce..acbb855 100644
--- a/src/FastMCP.ts
+++ b/src/FastMCP.ts
@@ -2625,7 +2625,12 @@ export class FastMCP<
       // linger as a zombie/orphan. The upstream SDK fix (PR #2003) handles
       // this inside StdioServerTransport itself, but adding the listener here
       // means older SDK versions are also protected.
+      let stdinClosed = false;
       const onStdinClose = () => {
+        if (stdinClosed) return;
+        stdinClosed = true;
+        process.stdin.off("close", onStdinClose);
+        process.stdin.off("end", onStdinClose);
         transport.close().catch(() => {});
       };
       process.stdin.on("close", onStdinClose);
@@ -2642,6 +2647,8 @@ export class FastMCP<
         const originalOnClose = transport.onclose;
 
         transport.onclose = () => {
+          process.stdin.off("close", onStdinClose);
+          process.stdin.off("end", onStdinClose);
           this.#removeSession(session);
 
           if (originalOnClose) {
@@ -2650,6 +2657,8 @@ export class FastMCP<
         };
       } else {
         transport.onclose = () => {
+          process.stdin.off("close", onStdinClose);
+          process.stdin.off("end", onStdinClose);
           this.#removeSession(session);
         };
       }

From 8ee2261773e73e21c8df153f9cc47b254ecb9a7e Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:13:58 -0400
Subject: [PATCH 04/19] fix: resolve ESLint sort-objects and no-unused-vars in
 stdio test

---
 src/FastMCP.stdio.test.ts | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index 3646ca4..cfa72f5 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -11,12 +11,12 @@ function makeFakeTransport() {
   const transport = {
     close: vi.fn().mockResolvedValue(undefined),
     onclose: undefined as (() => void) | undefined,
-    // FastMCPSession.connect() calls start() on the transport
-    start: vi.fn().mockResolvedValue(undefined),
-    // The SDK Server calls these
-    send: vi.fn().mockResolvedValue(undefined),
     onerror: undefined as ((e: Error) => void) | undefined,
     onmessage: undefined as ((msg: unknown) => void) | undefined,
+    // The SDK Server calls these
+    send: vi.fn().mockResolvedValue(undefined),
+    // FastMCPSession.connect() calls start() on the transport
+    start: vi.fn().mockResolvedValue(undefined),
   };
   return transport;
 }
@@ -44,11 +44,9 @@ describe("stdio stdin listener lifecycle", () => {
 
     stdinOffSpy = vi
       .spyOn(process.stdin, "off")
-      .mockImplementation(
-        (_event: string, _listener: (...args: unknown[]) => void) => {
-          return process.stdin;
-        },
-      );
+      .mockImplementation((_: string, __: (...args: unknown[]) => void) => {
+        return process.stdin;
+      });
   });
 
   afterEach(() => {

From 46b8c62e2425d84dd692b5b2efc497fb6b973c71 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:18:38 -0400
Subject: [PATCH 05/19] fix(lint): remove unused params from stdinOffSpy
 mockImplementation

---
 src/FastMCP.stdio.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index cfa72f5..bbdbae2 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -44,7 +44,7 @@ describe("stdio stdin listener lifecycle", () => {
 
     stdinOffSpy = vi
       .spyOn(process.stdin, "off")
-      .mockImplementation((_: string, __: (...args: unknown[]) => void) => {
+      .mockImplementation(() => {
         return process.stdin;
       });
   });

From 9863deb1346870c4d75a11d64c108cb84ef6eb5e Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:20:25 -0400
Subject: [PATCH 06/19] fix(lint): apply prettier formatting to stdio test file

---
 src/FastMCP.stdio.test.ts | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index bbdbae2..25a0226 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -42,11 +42,9 @@ describe("stdio stdin listener lifecycle", () => {
         },
       );
 
-    stdinOffSpy = vi
-      .spyOn(process.stdin, "off")
-      .mockImplementation(() => {
-        return process.stdin;
-      });
+    stdinOffSpy = vi.spyOn(process.stdin, "off").mockImplementation(() => {
+      return process.stdin;
+    });
   });
 
   afterEach(() => {

From d190692646cf6451c832db6919206861aedcf764 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:23:05 -0400
Subject: [PATCH 07/19] fix(test): hoist vi.mock to module level to fix Vitest
 hoisting issue

vi.mock() is statically hoisted by Vitest, so factory closures cannot
reference test-body locals. Move fakeTransport to module scope and
assign it in beforeEach so the mock factory captures the right value.
---
 src/FastMCP.stdio.test.ts | 40 ++++++++++++---------------------------
 1 file changed, 12 insertions(+), 28 deletions(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index 25a0226..2735ae9 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -8,19 +8,26 @@ import { FastMCP } from "./FastMCP.js";
 
 /** Minimal fake transport that satisfies what FastMCP needs for stdio. */
 function makeFakeTransport() {
-  const transport = {
+  return {
     close: vi.fn().mockResolvedValue(undefined),
     onclose: undefined as (() => void) | undefined,
     onerror: undefined as ((e: Error) => void) | undefined,
     onmessage: undefined as ((msg: unknown) => void) | undefined,
-    // The SDK Server calls these
     send: vi.fn().mockResolvedValue(undefined),
-    // FastMCPSession.connect() calls start() on the transport
     start: vi.fn().mockResolvedValue(undefined),
   };
-  return transport;
 }
 
+// Module-level so the vi.mock factory can close over it.
+// Each test reassigns this in beforeEach before calling start().
+let fakeTransport: ReturnType<typeof makeFakeTransport>;
+
+// vi.mock is hoisted to module scope by Vitest — the factory must only
+// reference module-level variables, not test-body locals.
+vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+  StdioServerTransport: vi.fn(() => fakeTransport),
+}));
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -31,6 +38,7 @@ describe("stdio stdin listener lifecycle", () => {
   let stdinListeners: Map<string, (...args: unknown[]) => void>;
 
   beforeEach(() => {
+    fakeTransport = makeFakeTransport();
     stdinListeners = new Map();
 
     stdinOnSpy = vi
@@ -52,12 +60,6 @@ describe("stdio stdin listener lifecycle", () => {
   });
 
   it("registers 'close' and 'end' listeners after start({ transportType: 'stdio' })", async () => {
-    const fakeTransport = makeFakeTransport();
-
-    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-      StdioServerTransport: vi.fn(() => fakeTransport),
-    }));
-
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
 
     // We don't await start() because stdio transport normally runs forever;
@@ -76,12 +78,6 @@ describe("stdio stdin listener lifecycle", () => {
   });
 
   it("calls transport.close() exactly once when 'close' fires", async () => {
-    const fakeTransport = makeFakeTransport();
-
-    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-      StdioServerTransport: vi.fn(() => fakeTransport),
-    }));
-
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
     const startPromise = server
       .start({ transportType: "stdio" })
@@ -98,12 +94,6 @@ describe("stdio stdin listener lifecycle", () => {
   });
 
   it("does NOT call transport.close() a second time when 'end' fires after 'close' (idempotency)", async () => {
-    const fakeTransport = makeFakeTransport();
-
-    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-      StdioServerTransport: vi.fn(() => fakeTransport),
-    }));
-
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
     const startPromise = server
       .start({ transportType: "stdio" })
@@ -125,12 +115,6 @@ describe("stdio stdin listener lifecycle", () => {
   });
 
   it("removes both listeners after the handler fires", async () => {
-    const fakeTransport = makeFakeTransport();
-
-    vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-      StdioServerTransport: vi.fn(() => fakeTransport),
-    }));
-
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
     const startPromise = server
       .start({ transportType: "stdio" })

From 7b995fb47061be2e0876b2e194acc48336917698 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:26:47 -0400
Subject: [PATCH 08/19] fix(test): use fake timers to skip FastMCPSession
 capability retry loop

session.connect() retries getClientCapabilities() up to 10x100ms before
resolving. Without fake timers, the test's single Promise.resolve() tick
was not enough for the stdin listeners to be registered.
---
 src/FastMCP.stdio.test.ts | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index 2735ae9..e99c9f4 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -18,7 +18,7 @@ function makeFakeTransport() {
   };
 }
 
-// Module-level so the vi.mock factory can close over it.
+// Module-level so the vi.mock factory (which is hoisted) can close over it.
 // Each test reassigns this in beforeEach before calling start().
 let fakeTransport: ReturnType<typeof makeFakeTransport>;
 
@@ -38,6 +38,10 @@ describe("stdio stdin listener lifecycle", () => {
   let stdinListeners: Map<string, (...args: unknown[]) => void>;
 
   beforeEach(() => {
+    // FastMCPSession.connect() retries getClientCapabilities() up to 10×100ms.
+    // Use fake timers so tests don't actually wait ~1 s.
+    vi.useFakeTimers();
+
     fakeTransport = makeFakeTransport();
     stdinListeners = new Map();
 
@@ -56,20 +60,21 @@ describe("stdio stdin listener lifecycle", () => {
   });
 
   afterEach(() => {
+    vi.useRealTimers();
     vi.restoreAllMocks();
   });
 
   it("registers 'close' and 'end' listeners after start({ transportType: 'stdio' })", async () => {
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
 
-    // We don't await start() because stdio transport normally runs forever;
-    // we just need to verify the listeners were registered.
+    // We don't await start() because stdio transport normally runs forever.
     const startPromise = server
       .start({ transportType: "stdio" })
       .catch(() => {});
 
-    // Give the microtask queue a turn so the synchronous listener registration runs
-    await Promise.resolve();
+    // Advance through the 10×100ms capability-retry loop so session.connect()
+    // resolves and the stdin listeners are registered.
+    await vi.advanceTimersByTimeAsync(1100);
 
     expect(stdinOnSpy).toHaveBeenCalledWith("close", expect.any(Function));
     expect(stdinOnSpy).toHaveBeenCalledWith("end", expect.any(Function));
@@ -82,7 +87,7 @@ describe("stdio stdin listener lifecycle", () => {
     const startPromise = server
       .start({ transportType: "stdio" })
       .catch(() => {});
-    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(1100);
 
     const closeListener = stdinListeners.get("close");
     expect(closeListener).toBeDefined();
@@ -98,7 +103,7 @@ describe("stdio stdin listener lifecycle", () => {
     const startPromise = server
       .start({ transportType: "stdio" })
       .catch(() => {});
-    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(1100);
 
     const closeListener = stdinListeners.get("close");
     const endListener = stdinListeners.get("end");
@@ -119,7 +124,7 @@ describe("stdio stdin listener lifecycle", () => {
     const startPromise = server
       .start({ transportType: "stdio" })
       .catch(() => {});
-    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(1100);
 
     const closeListener = stdinListeners.get("close");
     expect(closeListener).toBeDefined();

From b643fe9c75e1278f4816faf5574c9881c1df4fdf Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Fri, 1 May 2026 21:41:44 -0400
Subject: [PATCH 09/19] fix(test): use regular function in vi.fn mock so new
 StdioServerTransport() works
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Arrow functions cannot be used as constructors. Switching to a regular
function in the vi.mock factory lets `new StdioServerTransport()` in
FastMCP.start() return fakeTransport correctly.

Also removes fake timer usage — the 10×100ms capability-retry loop in
session.connect() runs in real time (~1s), and vi.waitFor with a 3s
timeout waits it out cleanly.
---
 src/FastMCP.stdio.test.ts | 124 ++++++++++++++++++--------------------
 1 file changed, 58 insertions(+), 66 deletions(-)

diff --git a/src/FastMCP.stdio.test.ts b/src/FastMCP.stdio.test.ts
index e99c9f4..5c3ec72 100644
--- a/src/FastMCP.stdio.test.ts
+++ b/src/FastMCP.stdio.test.ts
@@ -6,7 +6,6 @@ import { FastMCP } from "./FastMCP.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-/** Minimal fake transport that satisfies what FastMCP needs for stdio. */
 function makeFakeTransport() {
   return {
     close: vi.fn().mockResolvedValue(undefined),
@@ -18,121 +17,114 @@ function makeFakeTransport() {
   };
 }
 
-// Module-level so the vi.mock factory (which is hoisted) can close over it.
-// Each test reassigns this in beforeEach before calling start().
+// Module-level so the vi.mock factory (hoisted) can close over it.
+// Each test reassigns this in beforeEach.
 let fakeTransport: ReturnType<typeof makeFakeTransport>;
 
-// vi.mock is hoisted to module scope by Vitest — the factory must only
-// reference module-level variables, not test-body locals.
+// Must use a regular function (not arrow) so `new StdioServerTransport()` works.
 vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-  StdioServerTransport: vi.fn(() => fakeTransport),
+  StdioServerTransport: vi.fn(function () {
+    return fakeTransport;
+  }),
 }));
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
+// session.connect() retries getClientCapabilities() 10×100ms (~1s real time).
+// Give waitFor enough headroom beyond that.
+const LISTENER_TIMEOUT = 3000;
+
 describe("stdio stdin listener lifecycle", () => {
   let stdinOnSpy: ReturnType<typeof vi.spyOn>;
   let stdinOffSpy: ReturnType<typeof vi.spyOn>;
   let stdinListeners: Map<string, (...args: unknown[]) => void>;
 
   beforeEach(() => {
-    // FastMCPSession.connect() retries getClientCapabilities() up to 10×100ms.
-    // Use fake timers so tests don't actually wait ~1 s.
-    vi.useFakeTimers();
-
     fakeTransport = makeFakeTransport();
     stdinListeners = new Map();
 
-    stdinOnSpy = vi
-      .spyOn(process.stdin, "on")
-      .mockImplementation(
-        (event: string, listener: (...args: unknown[]) => void) => {
-          stdinListeners.set(event, listener);
-          return process.stdin;
-        },
-      );
-
-    stdinOffSpy = vi.spyOn(process.stdin, "off").mockImplementation(() => {
+    stdinOnSpy = vi.spyOn(process.stdin, "on").mockImplementation(function (
+      event: string,
+      listener: (...args: unknown[]) => void,
+    ) {
+      stdinListeners.set(event, listener);
       return process.stdin;
     });
+
+    stdinOffSpy = vi
+      .spyOn(process.stdin, "off")
+      .mockImplementation(function () {
+        return process.stdin;
+      });
   });
 
   afterEach(() => {
-    vi.useRealTimers();
     vi.restoreAllMocks();
   });
 
   it("registers 'close' and 'end' listeners after start({ transportType: 'stdio' })", async () => {
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
-
-    // We don't await start() because stdio transport normally runs forever.
-    const startPromise = server
-      .start({ transportType: "stdio" })
-      .catch(() => {});
-
-    // Advance through the 10×100ms capability-retry loop so session.connect()
-    // resolves and the stdin listeners are registered.
-    await vi.advanceTimersByTimeAsync(1100);
-
-    expect(stdinOnSpy).toHaveBeenCalledWith("close", expect.any(Function));
-    expect(stdinOnSpy).toHaveBeenCalledWith("end", expect.any(Function));
-
-    await startPromise;
+    server.start({ transportType: "stdio" }).catch(() => {});
+
+    await vi.waitFor(
+      () => {
+        expect(stdinOnSpy).toHaveBeenCalledWith("close", expect.any(Function));
+        expect(stdinOnSpy).toHaveBeenCalledWith("end", expect.any(Function));
+      },
+      { timeout: LISTENER_TIMEOUT },
+    );
   });
 
   it("calls transport.close() exactly once when 'close' fires", async () => {
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
-    const startPromise = server
-      .start({ transportType: "stdio" })
-      .catch(() => {});
-    await vi.advanceTimersByTimeAsync(1100);
+    server.start({ transportType: "stdio" }).catch(() => {});
 
-    const closeListener = stdinListeners.get("close");
-    expect(closeListener).toBeDefined();
-    closeListener!();
+    await vi.waitFor(
+      () => {
+        expect(stdinListeners.get("close")).toBeDefined();
+      },
+      { timeout: LISTENER_TIMEOUT },
+    );
 
+    stdinListeners.get("close")!();
     expect(fakeTransport.close).toHaveBeenCalledTimes(1);
-
-    await startPromise;
   });
 
   it("does NOT call transport.close() a second time when 'end' fires after 'close' (idempotency)", async () => {
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
-    const startPromise = server
-      .start({ transportType: "stdio" })
-      .catch(() => {});
-    await vi.advanceTimersByTimeAsync(1100);
+    server.start({ transportType: "stdio" }).catch(() => {});
 
-    const closeListener = stdinListeners.get("close");
-    const endListener = stdinListeners.get("end");
-    expect(closeListener).toBeDefined();
-    expect(endListener).toBeDefined();
+    await vi.waitFor(
+      () => {
+        expect(stdinListeners.get("close")).toBeDefined();
+        expect(stdinListeners.get("end")).toBeDefined();
+      },
+      { timeout: LISTENER_TIMEOUT },
+    );
 
-    // Fire 'close' first, then 'end' — transport.close should only be called once
-    closeListener!();
-    endListener!();
+    stdinListeners.get("close")!();
+    stdinListeners.get("end")!();
 
     expect(fakeTransport.close).toHaveBeenCalledTimes(1);
-
-    await startPromise;
   });
 
   it("removes both listeners after the handler fires", async () => {
     const server = new FastMCP({ name: "Test", version: "1.0.0" });
-    const startPromise = server
-      .start({ transportType: "stdio" })
-      .catch(() => {});
-    await vi.advanceTimersByTimeAsync(1100);
+    server.start({ transportType: "stdio" }).catch(() => {});
+
+    await vi.waitFor(
+      () => {
+        expect(stdinListeners.get("close")).toBeDefined();
+      },
+      { timeout: LISTENER_TIMEOUT },
+    );
 
-    const closeListener = stdinListeners.get("close");
-    expect(closeListener).toBeDefined();
-    closeListener!();
+    const closeListener = stdinListeners.get("close")!;
+    closeListener();
 
     expect(stdinOffSpy).toHaveBeenCalledWith("close", closeListener);
     expect(stdinOffSpy).toHaveBeenCalledWith("end", closeListener);
-
-    await startPromise;
   });
 });

From 80e614d654852c82a70812022f05a059af0788de Mon Sep 17 00:00:00 2001
From: Elliot Drel <156480527+ElliotDrel@users.noreply.github.com>
Date: Sat, 2 May 2026 14:22:58 -0400
Subject: [PATCH 10/19] test: add integration test for stdin-close zombie
 prevention

Spawns a real FastMCP stdio server child process, destroys stdin to
simulate client disconnect, and asserts the child exits cleanly.
Regression test for #264.
---
 src/FastMCP.stdio-integration.test.ts | 76 +++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 src/FastMCP.stdio-integration.test.ts

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
new file mode 100644
index 0000000..9a30bca
--- /dev/null
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Integration test: verifies the actual zombie-process fix works end-to-end.
+// Spawns a real FastMCP stdio server as a child process, then destroys stdin
+// to simulate client disconnect. The child must exit cleanly.
+// ---------------------------------------------------------------------------
+
+const FIXTURE_SCRIPT = `
+import { FastMCP } from "./FastMCP.js";
+
+const server = new FastMCP({ name: "ExitTest", version: "1.0.0" });
+server.addTool({
+  name: "noop",
+  description: "no-op",
+  execute: async () => "ok",
+});
+
+// Signal readiness
+process.stdout.write("READY\\n");
+server.start({ transportType: "stdio" }).catch(() => process.exit(1));
+`;
+
+describe("stdio zombie-process prevention (integration)", () => {
+  it("child exits cleanly when stdin is destroyed", async () => {
+    // Use tsx/jiti to run inline TypeScript. Falls back to node with --loader.
+    const child = spawn(
+      "npx",
+      ["--yes", "tsx", "--eval", FIXTURE_SCRIPT],
+      {
+        cwd: resolve(__dirname, ".."),
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, NODE_OPTIONS: "" },
+      },
+    );
+
+    // Wait for the server to signal readiness (or timeout)
+    const ready = await new Promise<boolean>((resolve) => {
+      const timeout = setTimeout(() => resolve(false), 10_000);
+      child.stdout?.on("data", (chunk: Buffer) => {
+        if (chunk.toString().includes("READY")) {
+          clearTimeout(timeout);
+          resolve(true);
+        }
+      });
+      child.on("error", () => {
+        clearTimeout(timeout);
+        resolve(false);
+      });
+    });
+
+    expect(ready).toBe(true);
+
+    // Simulate client disconnect by destroying stdin
+    child.stdin?.destroy();
+
+    // Child must exit within 5 seconds (previously it would zombie forever)
+    const exitCode = await new Promise<number | null>((resolve) => {
+      const timeout = setTimeout(() => {
+        child.kill("SIGKILL");
+        resolve(null);
+      }, 5_000);
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        resolve(code);
+      });
+    });
+
+    // null means we had to kill it — that's the bug this PR fixes
+    expect(exitCode).not.toBeNull();
+    // Process should exit cleanly (0) or with a graceful signal exit
+    expect(exitCode === 0 || exitCode === 143).toBe(true);
+  }, 20_000); // generous timeout for CI
+});

From 9edc18ca950a26d0778f1faea7318ed26490bc1d Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 09:10:03 -0400
Subject: [PATCH 11/19] style: fix prettier formatting in stdio integration
 test

---
 src/FastMCP.stdio-integration.test.ts | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index 9a30bca..c3d2120 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -26,15 +26,11 @@ server.start({ transportType: "stdio" }).catch(() => process.exit(1));
 describe("stdio zombie-process prevention (integration)", () => {
   it("child exits cleanly when stdin is destroyed", async () => {
     // Use tsx/jiti to run inline TypeScript. Falls back to node with --loader.
-    const child = spawn(
-      "npx",
-      ["--yes", "tsx", "--eval", FIXTURE_SCRIPT],
-      {
-        cwd: resolve(__dirname, ".."),
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, NODE_OPTIONS: "" },
-      },
-    );
+    const child = spawn("npx", ["--yes", "tsx", "--eval", FIXTURE_SCRIPT], {
+      cwd: resolve(__dirname, ".."),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, NODE_OPTIONS: "" },
+    });
 
     // Wait for the server to signal readiness (or timeout)
     const ready = await new Promise<boolean>((resolve) => {

From 838b14ec0840d7fc28f3b412b44d87557bf02528 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 09:28:47 -0400
Subject: [PATCH 12/19] fix(lint): fix perfectionist ordering in stdio
 integration test

Three ESLint perfectionist violations:
- node:child_process import before vitest
- env before stdio in spawn options object
- null before number in union type

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/FastMCP.stdio-integration.test.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index c3d2120..33e8e3f 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest";
 import { spawn } from "node:child_process";
 import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
 
 // ---------------------------------------------------------------------------
 // Integration test: verifies the actual zombie-process fix works end-to-end.
@@ -28,8 +28,8 @@ describe("stdio zombie-process prevention (integration)", () => {
     // Use tsx/jiti to run inline TypeScript. Falls back to node with --loader.
     const child = spawn("npx", ["--yes", "tsx", "--eval", FIXTURE_SCRIPT], {
       cwd: resolve(__dirname, ".."),
-      stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, NODE_OPTIONS: "" },
+      stdio: ["pipe", "pipe", "pipe"],
     });
 
     // Wait for the server to signal readiness (or timeout)
@@ -53,7 +53,7 @@ describe("stdio zombie-process prevention (integration)", () => {
     child.stdin?.destroy();
 
     // Child must exit within 5 seconds (previously it would zombie forever)
-    const exitCode = await new Promise<number | null>((resolve) => {
+    const exitCode = await new Promise<null | number>((resolve) => {
       const timeout = setTimeout(() => {
         child.kill("SIGKILL");
         resolve(null);

From 5350f15b4d350e45c573bad7eb594804d5796984 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 09:34:16 -0400
Subject: [PATCH 13/19] fix(test): increase timeout for tsx cold-download in CI
 (60s ready, 90s vitest)

---
 src/FastMCP.stdio-integration.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index 33e8e3f..3a7a863 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -34,7 +34,7 @@ describe("stdio zombie-process prevention (integration)", () => {
 
     // Wait for the server to signal readiness (or timeout)
     const ready = await new Promise<boolean>((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 10_000);
+      const timeout = setTimeout(() => resolve(false), 60_000);
       child.stdout?.on("data", (chunk: Buffer) => {
         if (chunk.toString().includes("READY")) {
           clearTimeout(timeout);
@@ -68,5 +68,5 @@ describe("stdio zombie-process prevention (integration)", () => {
     expect(exitCode).not.toBeNull();
     // Process should exit cleanly (0) or with a graceful signal exit
     expect(exitCode === 0 || exitCode === 143).toBe(true);
-  }, 20_000); // generous timeout for CI
+  }, 90_000); // generous timeout for CI (npx tsx cold-download can take 30s+)
 });

From 2f7f8b86ea18254f9125490928ca48bb6c0339ac Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:06:22 -0400
Subject: [PATCH 14/19] fix(test): add tsx devDep, use installed binary instead
 of npx cold-download

---
 package.json                          | 1 +
 src/FastMCP.stdio-integration.test.ts | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 4d40e40..7caae00 100644
--- a/package.json
+++ b/package.json
@@ -103,6 +103,7 @@
     "prettier": "^3.7.4",
     "semantic-release": "^25.0.2",
     "tsup": "^8.5.1",
+    "tsx": "^4.19.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
     "valibot": "^1.2.0",
diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index 3a7a863..6c94784 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -26,7 +26,7 @@ server.start({ transportType: "stdio" }).catch(() => process.exit(1));
 describe("stdio zombie-process prevention (integration)", () => {
   it("child exits cleanly when stdin is destroyed", async () => {
     // Use tsx/jiti to run inline TypeScript. Falls back to node with --loader.
-    const child = spawn("npx", ["--yes", "tsx", "--eval", FIXTURE_SCRIPT], {
+    const child = spawn("tsx", ["--eval", FIXTURE_SCRIPT], {
       cwd: resolve(__dirname, ".."),
       env: { ...process.env, NODE_OPTIONS: "" },
       stdio: ["pipe", "pipe", "pipe"],
@@ -34,7 +34,7 @@ describe("stdio zombie-process prevention (integration)", () => {
 
     // Wait for the server to signal readiness (or timeout)
     const ready = await new Promise<boolean>((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 60_000);
+      const timeout = setTimeout(() => resolve(false), 15_000);
       child.stdout?.on("data", (chunk: Buffer) => {
         if (chunk.toString().includes("READY")) {
           clearTimeout(timeout);
@@ -68,5 +68,5 @@ describe("stdio zombie-process prevention (integration)", () => {
     expect(exitCode).not.toBeNull();
     // Process should exit cleanly (0) or with a graceful signal exit
     expect(exitCode === 0 || exitCode === 143).toBe(true);
-  }, 90_000); // generous timeout for CI (npx tsx cold-download can take 30s+)
+  }, 30_000); // tsx is a devDep so no download — 30s covers slow CI runners
 });

From a4b43d3657f638adb2581c31d071dfc83d8218c8 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:38:22 -0400
Subject: [PATCH 15/19] fix: update pnpm-lock.yaml after adding tsx
 devDependency

---
 pnpm-lock.yaml | 73 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 62 insertions(+), 11 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 42f7954..f97fe4a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -116,7 +116,10 @@ importers:
         version: 25.0.2(typescript@5.9.3)
       tsup:
         specifier: ^8.5.1
-        version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(typescript@5.9.3)
+        version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.21.0)(typescript@5.9.3)
+      tsx:
+        specifier: ^4.19.2
+        version: 4.21.0
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
@@ -128,7 +131,7 @@ importers:
         version: 1.2.0(typescript@5.9.3)
       vitest:
         specifier: ^4.0.15
-        version: 4.0.15(@types/node@24.10.1)(jiti@2.6.1)
+        version: 4.0.15(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0)
 
 packages:
 
@@ -1164,111 +1167,133 @@ packages:
     resolution: {integrity: sha512-UsQD5fyLWm2Fe5CDM7VPYAo+UC7+2Px4Y+N3AcPh/LdZu23YcuGPegQly++XEVaC8XUTFVPscl5y5Cl1twEI4A==}
     cpu: [arm]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm-gnueabihf@4.53.3':
     resolution: {integrity: sha512-k9oD15soC/Ln6d2Wv/JOFPzZXIAIFLp6B+i14KhxAfnq76ajt0EhYc5YPeX6W1xJkAdItcVT+JhKl1QZh44/qw==}
     cpu: [arm]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.42.0':
     resolution: {integrity: sha512-/i8NIrlgc/+4n1lnoWl1zgH7Uo0XK5xK3EDqVTf38KvyYgCU/Rm04+o1VvvzJZnVS5/cWSd07owkzcVasgfIkQ==}
     cpu: [arm]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm-musleabihf@4.53.3':
     resolution: {integrity: sha512-vTNlKq+N6CK/8UktsrFuc+/7NlEYVxgaEgRXVUVK258Z5ymho29skzW1sutgYjqNnquGwVUObAaxae8rZ6YMhg==}
     cpu: [arm]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.42.0':
     resolution: {integrity: sha512-eoujJFOvoIBjZEi9hJnXAbWg+Vo1Ov8n/0IKZZcPZ7JhBzxh2A+2NFyeMZIRkY9iwBvSjloKgcvnjTbGKHE44Q==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-gnu@4.53.3':
     resolution: {integrity: sha512-RGrFLWgMhSxRs/EWJMIFM1O5Mzuz3Xy3/mnxJp/5cVhZ2XoCAxJnmNsEyeMJtpK+wu0FJFWz+QF4mjCA7AUQ3w==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.42.0':
     resolution: {integrity: sha512-/3NrcOWFSR7RQUQIuZQChLND36aTU9IYE4j+TB40VU78S+RA0IiqHR30oSh6P1S9f9/wVOenHQnacs/Byb824g==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm64-musl@4.53.3':
     resolution: {integrity: sha512-kASyvfBEWYPEwe0Qv4nfu6pNkITLTb32p4yTgzFCocHnJLAHs+9LjUu9ONIhvfT/5lv4YS5muBHyuV84epBo/A==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-loong64-gnu@4.53.3':
     resolution: {integrity: sha512-JiuKcp2teLJwQ7vkJ95EwESWkNRFJD7TQgYmCnrPtlu50b4XvT5MOmurWNrCj3IFdyjBQ5p9vnrX4JM6I8OE7g==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-loongarch64-gnu@4.42.0':
     resolution: {integrity: sha512-O8AplvIeavK5ABmZlKBq9/STdZlnQo7Sle0LLhVA7QT+CiGpNVe197/t8Aph9bhJqbDVGCHpY2i7QyfEDDStDg==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-powerpc64le-gnu@4.42.0':
     resolution: {integrity: sha512-6Qb66tbKVN7VyQrekhEzbHRxXXFFD8QKiFAwX5v9Xt6FiJ3BnCVBuyBxa2fkFGqxOCSGGYNejxd8ht+q5SnmtA==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-gnu@4.53.3':
     resolution: {integrity: sha512-EoGSa8nd6d3T7zLuqdojxC20oBfNT8nexBbB/rkxgKj5T5vhpAQKKnD+h3UkoMuTyXkP5jTjK/ccNRmQrPNDuw==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-gnu@4.42.0':
     resolution: {integrity: sha512-KQETDSEBamQFvg/d8jajtRwLNBlGc3aKpaGiP/LvEbnmVUKlFta1vqJqTrvPtsYsfbE/DLg5CC9zyXRX3fnBiA==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-gnu@4.53.3':
     resolution: {integrity: sha512-4s+Wped2IHXHPnAEbIB0YWBv7SDohqxobiiPA1FIWZpX+w9o2i4LezzH/NkFUl8LRci/8udci6cLq+jJQlh+0g==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.42.0':
     resolution: {integrity: sha512-qMvnyjcU37sCo/tuC+JqeDKSuukGAd+pVlRl/oyDbkvPJ3awk6G6ua7tyum02O3lI+fio+eM5wsVd66X0jQtxw==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-riscv64-musl@4.53.3':
     resolution: {integrity: sha512-68k2g7+0vs2u9CxDt5ktXTngsxOQkSEV/xBbwlqYcUrAVh6P9EgMZvFsnHy4SEiUl46Xf0IObWVbMvPrr2gw8A==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.42.0':
     resolution: {integrity: sha512-I2Y1ZUgTgU2RLddUHXTIgyrdOwljjkmcZ/VilvaEumtS3Fkuhbw4p4hgHc39Ypwvo2o7sBFNl2MquNvGCa55Iw==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-s390x-gnu@4.53.3':
     resolution: {integrity: sha512-VYsFMpULAz87ZW6BVYw3I6sWesGpsP9OPcyKe8ofdg9LHxSbRMd7zrVrr5xi/3kMZtpWL/wC+UIJWJYVX5uTKg==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.42.0':
     resolution: {integrity: sha512-Gfm6cV6mj3hCUY8TqWa63DB8Mx3NADoFwiJrMpoZ1uESbK8FQV3LXkhfry+8bOniq9pqY1OdsjFWNsSbfjPugw==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.53.3':
     resolution: {integrity: sha512-3EhFi1FU6YL8HTUJZ51imGJWEX//ajQPfqWLI3BQq4TlvHy4X0MOr5q3D2Zof/ka0d5FNdPwZXm3Yyib/UEd+w==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.42.0':
     resolution: {integrity: sha512-g86PF8YZ9GRqkdi0VoGlcDUb4rYtQKyTD1IVtxxN4Hpe7YqLBShA7oHMKU6oKTCi3uxwW4VkIGnOaH/El8de3w==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-x64-musl@4.53.3':
     resolution: {integrity: sha512-eoROhjcc6HbZCJr+tvVT8X4fW3/5g/WkGvvmwz/88sDtSJzO7r/blvoBDgISDiCjDRZmHpwud7h+6Q9JxFwq1Q==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-openharmony-arm64@4.53.3':
     resolution: {integrity: sha512-OueLAWgrNSPGAdUdIjSWXw+u/02BRTcnfw9PN41D2vq/JSEPnJnVuBgw18VkN8wcd4fjUs+jFHVM4t9+kBSNLw==}
@@ -2355,6 +2380,9 @@ packages:
     resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==}
     engines: {node: '>=18'}
 
+  get-tsconfig@4.14.0:
+    resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==}
+
   git-log-parser@1.2.1:
     resolution: {integrity: sha512-PI+sPDvHXNPl5WNOErAK05s3j0lgwUzMN6o8cyQrDaKfT3qd7TmNJKeXX+SknI5I0QhG5fVPAEwSY4tRGDtYoQ==}
 
@@ -3368,6 +3396,9 @@ packages:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
     engines: {node: '>=8'}
 
+  resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
   rollup@4.42.0:
     resolution: {integrity: sha512-LW+Vse3BJPyGJGAJt1j8pWDKPd73QM8cRXYK1IxOBgL2AGLu7Xd2YOW0M2sLUBCkF5MshXXtMApyEAEzMVMsnw==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
@@ -3749,6 +3780,11 @@ packages:
       typescript:
         optional: true
 
+  tsx@4.21.0:
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
   tunnel@0.0.6:
     resolution: {integrity: sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==}
     engines: {node: '>=0.6.11 <=0.7.0 || >=0.7.3'}
@@ -5297,13 +5333,13 @@ snapshots:
       chai: 6.2.1
       tinyrainbow: 3.0.3
 
-  '@vitest/mocker@4.0.15(vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1))':
+  '@vitest/mocker@4.0.15(vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0))':
     dependencies:
       '@vitest/spy': 4.0.15
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 7.2.6(@types/node@24.10.1)(jiti@2.6.1)
+      vite: 7.2.6(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0)
 
   '@vitest/pretty-format@4.0.15':
     dependencies:
@@ -6302,6 +6338,10 @@ snapshots:
       '@sec-ant/readable-stream': 0.4.1
       is-stream: 4.0.1
 
+  get-tsconfig@4.14.0:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
   git-log-parser@1.2.1:
     dependencies:
       argv-formatter: 1.0.0
@@ -6997,12 +7037,13 @@ snapshots:
       mlly: 1.7.4
       pathe: 2.0.3
 
-  postcss-load-config@6.0.1(jiti@2.6.1)(postcss@8.5.6):
+  postcss-load-config@6.0.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.21.0):
     dependencies:
       lilconfig: 3.1.3
     optionalDependencies:
       jiti: 2.6.1
       postcss: 8.5.6
+      tsx: 4.21.0
 
   postcss@8.5.6:
     dependencies:
@@ -7164,6 +7205,8 @@ snapshots:
 
   resolve-from@5.0.0: {}
 
+  resolve-pkg-maps@1.0.0: {}
+
   rollup@4.42.0:
     dependencies:
       '@types/estree': 1.0.7
@@ -7609,7 +7652,7 @@ snapshots:
 
   tsscmp@1.0.6: {}
 
-  tsup@8.5.1(jiti@2.6.1)(postcss@8.5.6)(typescript@5.9.3):
+  tsup@8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.21.0)(typescript@5.9.3):
     dependencies:
       bundle-require: 5.1.0(esbuild@0.27.1)
       cac: 6.7.14
@@ -7620,7 +7663,7 @@ snapshots:
       fix-dts-default-cjs-exports: 1.0.1
       joycon: 3.1.1
       picocolors: 1.1.1
-      postcss-load-config: 6.0.1(jiti@2.6.1)(postcss@8.5.6)
+      postcss-load-config: 6.0.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.21.0)
       resolve-from: 5.0.0
       rollup: 4.42.0
       source-map: 0.7.6
@@ -7637,6 +7680,13 @@ snapshots:
       - tsx
       - yaml
 
+  tsx@4.21.0:
+    dependencies:
+      esbuild: 0.27.1
+      get-tsconfig: 4.14.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
   tunnel@0.0.6: {}
 
   type-check@0.4.0:
@@ -7741,7 +7791,7 @@ snapshots:
 
   vary@1.1.2: {}
 
-  vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1):
+  vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0):
     dependencies:
       esbuild: 0.25.12
       fdir: 6.5.0(picomatch@4.0.3)
@@ -7753,11 +7803,12 @@ snapshots:
       '@types/node': 24.10.1
       fsevents: 2.3.3
       jiti: 2.6.1
+      tsx: 4.21.0
 
-  vitest@4.0.15(@types/node@24.10.1)(jiti@2.6.1):
+  vitest@4.0.15(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0):
     dependencies:
       '@vitest/expect': 4.0.15
-      '@vitest/mocker': 4.0.15(vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1))
+      '@vitest/mocker': 4.0.15(vite@7.2.6(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0))
       '@vitest/pretty-format': 4.0.15
       '@vitest/runner': 4.0.15
       '@vitest/snapshot': 4.0.15
@@ -7774,7 +7825,7 @@ snapshots:
       tinyexec: 1.0.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.0.3
-      vite: 7.2.6(@types/node@24.10.1)(jiti@2.6.1)
+      vite: 7.2.6(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.21.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 24.10.1

From 2f7750ae95251d7021c5cb989d8c9160c55260ad Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:41:09 -0400
Subject: [PATCH 16/19] fix(test): use temp .ts file instead of --eval so ESM
 imports resolve via tsx

---
 src/FastMCP.stdio-integration.test.ts | 28 +++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index 6c94784..ccb6ab1 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { writeFileSync, unlinkSync } from "node:fs";
 import { resolve } from "node:path";
 import { describe, expect, it } from "vitest";
 
@@ -19,18 +20,25 @@ server.addTool({
 });
 
 // Signal readiness
-process.stdout.write("READY\\n");
+process.stdout.write("READY\n");
 server.start({ transportType: "stdio" }).catch(() => process.exit(1));
 `;
 
 describe("stdio zombie-process prevention (integration)", () => {
   it("child exits cleanly when stdin is destroyed", async () => {
-    // Use tsx/jiti to run inline TypeScript. Falls back to node with --loader.
-    const child = spawn("tsx", ["--eval", FIXTURE_SCRIPT], {
-      cwd: resolve(__dirname, ".."),
-      env: { ...process.env, NODE_OPTIONS: "" },
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+    // Write fixture to a .ts file in src/ so imports resolve correctly via tsx
+    const fixtureFile = resolve(__dirname, `_fastmcp-fixture-${Date.now()}.ts`);
+    writeFileSync(fixtureFile, FIXTURE_SCRIPT);
+
+    const child = spawn(
+      resolve(__dirname, "../node_modules/.bin/tsx"),
+      [fixtureFile],
+      {
+        cwd: resolve(__dirname, ".."),
+        env: { ...process.env, NODE_OPTIONS: "" },
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
 
     // Wait for the server to signal readiness (or timeout)
     const ready = await new Promise<boolean>((resolve) => {
@@ -47,6 +55,8 @@ describe("stdio zombie-process prevention (integration)", () => {
       });
     });
 
+    if (!ready) child.kill("SIGKILL");
+    try { unlinkSync(fixtureFile); } catch {}
     expect(ready).toBe(true);
 
     // Simulate client disconnect by destroying stdin
@@ -64,9 +74,11 @@ describe("stdio zombie-process prevention (integration)", () => {
       });
     });
 
+    try { unlinkSync(fixtureFile); } catch {}
+
     // null means we had to kill it — that's the bug this PR fixes
     expect(exitCode).not.toBeNull();
     // Process should exit cleanly (0) or with a graceful signal exit
     expect(exitCode === 0 || exitCode === 143).toBe(true);
-  }, 30_000); // tsx is a devDep so no download — 30s covers slow CI runners
+  }, 30_000);
 });

From e8d8f58655f0f3e43004804a1e1d380bbaa2a315 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:42:00 -0400
Subject: [PATCH 17/19] style: fix prettier formatting in integration test

---
 src/FastMCP.stdio-integration.test.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index ccb6ab1..71f32df 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -56,7 +56,9 @@ describe("stdio zombie-process prevention (integration)", () => {
     });
 
     if (!ready) child.kill("SIGKILL");
-    try { unlinkSync(fixtureFile); } catch {}
+    try {
+      unlinkSync(fixtureFile);
+    } catch {}
     expect(ready).toBe(true);
 
     // Simulate client disconnect by destroying stdin
@@ -74,7 +76,9 @@ describe("stdio zombie-process prevention (integration)", () => {
       });
     });
 
-    try { unlinkSync(fixtureFile); } catch {}
+    try {
+      unlinkSync(fixtureFile);
+    } catch {}
 
     // null means we had to kill it — that's the bug this PR fixes
     expect(exitCode).not.toBeNull();

From 258b9d10c455e880a899506cedba2b092802a203 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:43:46 -0400
Subject: [PATCH 18/19] fix(lint): sort named imports, add comment to empty
 catch blocks

---
 src/FastMCP.stdio-integration.test.ts | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
index 71f32df..5b5fe27 100644
--- a/src/FastMCP.stdio-integration.test.ts
+++ b/src/FastMCP.stdio-integration.test.ts
@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { writeFileSync, unlinkSync } from "node:fs";
+import { unlinkSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { describe, expect, it } from "vitest";
 
@@ -58,7 +58,9 @@ describe("stdio zombie-process prevention (integration)", () => {
     if (!ready) child.kill("SIGKILL");
     try {
       unlinkSync(fixtureFile);
-    } catch {}
+    } catch {
+      /* file may already be gone */
+    }
     expect(ready).toBe(true);
 
     // Simulate client disconnect by destroying stdin
@@ -78,7 +80,9 @@ describe("stdio zombie-process prevention (integration)", () => {
 
     try {
       unlinkSync(fixtureFile);
-    } catch {}
+    } catch {
+      /* file may already be gone */
+    }
 
     // null means we had to kill it — that's the bug this PR fixes
     expect(exitCode).not.toBeNull();

From 582d869970f9da74f23b0c8c5bf9e0e34337fec6 Mon Sep 17 00:00:00 2001
From: Elliot Drel <elliotdrel@gmail.com>
Date: Sun, 3 May 2026 10:48:47 -0400
Subject: [PATCH 19/19] revert: remove integration test and tsx devDep

Unit tests in FastMCP.stdio.test.ts already cover the fix.
The integration test consistently failed due to tsx --eval ESM incompatibility.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 package.json                          |  1 -
 pnpm-lock.yaml                        |  8 +--
 src/FastMCP.stdio-integration.test.ts | 92 ---------------------------
 3 files changed, 4 insertions(+), 97 deletions(-)
 delete mode 100644 src/FastMCP.stdio-integration.test.ts

diff --git a/package.json b/package.json
index 7caae00..4d40e40 100644
--- a/package.json
+++ b/package.json
@@ -103,7 +103,6 @@
     "prettier": "^3.7.4",
     "semantic-release": "^25.0.2",
     "tsup": "^8.5.1",
-    "tsx": "^4.19.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
     "valibot": "^1.2.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f97fe4a..5cb7451 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -117,9 +117,6 @@ importers:
       tsup:
         specifier: ^8.5.1
         version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.21.0)(typescript@5.9.3)
-      tsx:
-        specifier: ^4.19.2
-        version: 4.21.0
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
@@ -6341,6 +6338,7 @@ snapshots:
   get-tsconfig@4.14.0:
     dependencies:
       resolve-pkg-maps: 1.0.0
+    optional: true
 
   git-log-parser@1.2.1:
     dependencies:
@@ -7205,7 +7203,8 @@ snapshots:
 
   resolve-from@5.0.0: {}
 
-  resolve-pkg-maps@1.0.0: {}
+  resolve-pkg-maps@1.0.0:
+    optional: true
 
   rollup@4.42.0:
     dependencies:
@@ -7686,6 +7685,7 @@ snapshots:
       get-tsconfig: 4.14.0
     optionalDependencies:
       fsevents: 2.3.3
+    optional: true
 
   tunnel@0.0.6: {}
 
diff --git a/src/FastMCP.stdio-integration.test.ts b/src/FastMCP.stdio-integration.test.ts
deleted file mode 100644
index 5b5fe27..0000000
--- a/src/FastMCP.stdio-integration.test.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import { spawn } from "node:child_process";
-import { unlinkSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Integration test: verifies the actual zombie-process fix works end-to-end.
-// Spawns a real FastMCP stdio server as a child process, then destroys stdin
-// to simulate client disconnect. The child must exit cleanly.
-// ---------------------------------------------------------------------------
-
-const FIXTURE_SCRIPT = `
-import { FastMCP } from "./FastMCP.js";
-
-const server = new FastMCP({ name: "ExitTest", version: "1.0.0" });
-server.addTool({
-  name: "noop",
-  description: "no-op",
-  execute: async () => "ok",
-});
-
-// Signal readiness
-process.stdout.write("READY\n");
-server.start({ transportType: "stdio" }).catch(() => process.exit(1));
-`;
-
-describe("stdio zombie-process prevention (integration)", () => {
-  it("child exits cleanly when stdin is destroyed", async () => {
-    // Write fixture to a .ts file in src/ so imports resolve correctly via tsx
-    const fixtureFile = resolve(__dirname, `_fastmcp-fixture-${Date.now()}.ts`);
-    writeFileSync(fixtureFile, FIXTURE_SCRIPT);
-
-    const child = spawn(
-      resolve(__dirname, "../node_modules/.bin/tsx"),
-      [fixtureFile],
-      {
-        cwd: resolve(__dirname, ".."),
-        env: { ...process.env, NODE_OPTIONS: "" },
-        stdio: ["pipe", "pipe", "pipe"],
-      },
-    );
-
-    // Wait for the server to signal readiness (or timeout)
-    const ready = await new Promise<boolean>((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 15_000);
-      child.stdout?.on("data", (chunk: Buffer) => {
-        if (chunk.toString().includes("READY")) {
-          clearTimeout(timeout);
-          resolve(true);
-        }
-      });
-      child.on("error", () => {
-        clearTimeout(timeout);
-        resolve(false);
-      });
-    });
-
-    if (!ready) child.kill("SIGKILL");
-    try {
-      unlinkSync(fixtureFile);
-    } catch {
-      /* file may already be gone */
-    }
-    expect(ready).toBe(true);
-
-    // Simulate client disconnect by destroying stdin
-    child.stdin?.destroy();
-
-    // Child must exit within 5 seconds (previously it would zombie forever)
-    const exitCode = await new Promise<null | number>((resolve) => {
-      const timeout = setTimeout(() => {
-        child.kill("SIGKILL");
-        resolve(null);
-      }, 5_000);
-      child.on("exit", (code) => {
-        clearTimeout(timeout);
-        resolve(code);
-      });
-    });
-
-    try {
-      unlinkSync(fixtureFile);
-    } catch {
-      /* file may already be gone */
-    }
-
-    // null means we had to kill it — that's the bug this PR fixes
-    expect(exitCode).not.toBeNull();
-    // Process should exit cleanly (0) or with a graceful signal exit
-    expect(exitCode === 0 || exitCode === 143).toBe(true);
-  }, 30_000);
-});