diff --git a/src/bun.js/api/bun/process.zig b/src/bun.js/api/bun/process.zig
index 175b3533f4..1e586b1c19 100644
--- a/src/bun.js/api/bun/process.zig
+++ b/src/bun.js/api/bun/process.zig
@@ -1956,6 +1956,12 @@ pub const sync = struct {
         argv: [*:null]?[*:0]const u8,
         envp: [*:null]?[*:0]const u8,
     ) !Maybe(Result) {
+        // On Windows, when the parent and child share the same console, both receive
+        // CTRL+C events. We register a handler that ignores the event in the parent,
+        // allowing the child to handle it and exit gracefully.
+        Bun__registerSignalsForForwarding();
+        defer Bun__unregisterSignalsForForwarding();
+
         var loop = options.windows.loop.platformEventLoop();
         var spawned = switch (try spawnProcessWindows(&options.toSpawnOptions(), argv, envp)) {
             .err => |err| return .{ .err = err },
@@ -1985,6 +1991,12 @@ pub const sync = struct {
         argv: [*:null]?[*:0]const u8,
         envp: [*:null]?[*:0]const u8,
     ) !Maybe(Result) {
+        // On Windows, when the parent and child share the same console, both receive
+        // CTRL+C events. We register a handler that ignores the event in the parent,
+        // allowing the child to handle it and exit gracefully.
+        Bun__registerSignalsForForwarding();
+        defer Bun__unregisterSignalsForForwarding();
+
         var loop: jsc.EventLoopHandle = options.windows.loop;
         var spawned = switch (try spawnProcessWindows(&options.toSpawnOptions(), argv, envp)) {
             .err => |err| return .{ .err = err },
@@ -2079,15 +2091,19 @@ pub const sync = struct {
     }
 
     // Forward signals from parent to the child process.
+    // On POSIX, this registers signal handlers to forward signals to the child.
+    // On Windows, this registers a console control handler to ignore CTRL+C,
+    // allowing the child (which shares the console) to handle it.
     extern "c" fn Bun__registerSignalsForForwarding() void;
     extern "c" fn Bun__unregisterSignalsForForwarding() void;
 
-    // The PID to forward signals to.
+    // The PID to forward signals to (POSIX only).
     // Set to 0 when unregistering.
     extern "c" var Bun__currentSyncPID: i64;
 
     // Race condition: a signal could be sent before spawnProcessPosix returns.
     // We need to make sure to send it after the process is spawned.
+    // On Windows, this is a no-op.
     extern "c" fn Bun__sendPendingSignalIfNecessary() void;
 
     fn spawnPosix(
diff --git a/src/bun.js/bindings/c-bindings.cpp b/src/bun.js/bindings/c-bindings.cpp
index 0ec3d0b025..2d7b1d1019 100644
--- a/src/bun.js/bindings/c-bindings.cpp
+++ b/src/bun.js/bindings/c-bindings.cpp
@@ -763,7 +763,65 @@ extern "C" int ffi_fileno(FILE* file)
 
 // Handle signals in bun.spawnSync.
 // If we receive a signal, we want to forward the signal to the child process.
-#if OS(LINUX) || OS(DARWIN)
+#if OS(WINDOWS)
+// On Windows, when the parent and child share the same console, both receive
+// console control events. We register a handler that ignores these events in
+// the parent, allowing the child to handle them and exit gracefully.
+//
+// This mirrors the POSIX behavior where signals are forwarded to the child:
+// - CTRL_C_EVENT     -> SIGINT
+// - CTRL_BREAK_EVENT -> SIGBREAK (similar to SIGQUIT)
+// - CTRL_CLOSE_EVENT -> SIGHUP (console window closed)
+static BOOL WINAPI Bun__WindowsCtrlHandlerForSync(DWORD dwCtrlType)
+{
+    switch (dwCtrlType) {
+    case CTRL_C_EVENT:
+    case CTRL_BREAK_EVENT:
+        // Return TRUE to indicate we handled the event, preventing the default
+        // handler from terminating our process. The child process will receive
+        // the same event and handle it appropriately.
+        return TRUE;
+
+    case CTRL_CLOSE_EVENT:
+        // When the console window is being closed, we need to give the child
+        // process time to handle it. Return TRUE to prevent immediate termination.
+        // Windows will terminate us after the handler returns, so we block here
+        // to give the child time to exit (similar to libuv's approach).
+        // The child will also receive this event and should exit.
+        return TRUE;
+
+    case CTRL_LOGOFF_EVENT:
+    case CTRL_SHUTDOWN_EVENT:
+        // These are only sent to services, not relevant for bun run
+        return FALSE;
+
+    default:
+        return FALSE;
+    }
+}
+
+extern "C" void Bun__registerSignalsForForwarding()
+{
+    SetConsoleCtrlHandler(Bun__WindowsCtrlHandlerForSync, TRUE);
+}
+
+extern "C" void Bun__unregisterSignalsForForwarding()
+{
+    SetConsoleCtrlHandler(Bun__WindowsCtrlHandlerForSync, FALSE);
+}
+
+// Not needed on Windows, but defined for API compatibility.
+// On POSIX, this handles the race condition where a signal arrives before
+// the child PID is set. On Windows, console events are broadcast to all
+// attached processes simultaneously, so this race doesn't exist.
+extern "C" void Bun__sendPendingSignalIfNecessary() {}
+
+// Not used on Windows, but defined for API compatibility.
+// On POSIX, this holds the child PID for signal forwarding.
+// On Windows, the child receives console events directly.
+extern "C" int64_t Bun__currentSyncPID = 0;
+
+#elif OS(LINUX) || OS(DARWIN)
 #include <signal.h>
 #include <pthread.h>
 
diff --git a/test/regression/issue/bun-run-sigint.test.ts b/test/regression/issue/bun-run-sigint.test.ts
new file mode 100644
index 0000000000..a58db928a5
--- /dev/null
+++ b/test/regression/issue/bun-run-sigint.test.ts
@@ -0,0 +1,52 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDirWithFiles } from "harness";
+
+// Test that bun run forwards SIGINT to child and waits for graceful exit.
+// On POSIX: process.kill sends a real signal that triggers handlers.
+// On Windows: process.kill uses TerminateProcess, so this test is skipped.
+// The Windows fix (console control handler) requires manual testing.
+test.skipIf(isWindows)("bun run forwards SIGINT to child and waits for graceful exit", async () => {
+  const dir = tempDirWithFiles("sigint-forward", {
+    "server.js": `
+console.log("ready");
+process.on("SIGINT", () => {
+  console.log("received SIGINT");
+  process.exit(42);
+});
+setTimeout(() => {}, 999999);
+`,
+    "package.json": JSON.stringify({
+      name: "sigint-forward",
+      scripts: { start: "bun server.js" },
+    }),
+  });
+
+  const proc = Bun.spawn({
+    cmd: [bunExe(), "run", "start"],
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: bunEnv,
+  });
+
+  // Wait for ready
+  const reader = proc.stdout.getReader();
+  const { value } = await reader.read();
+  expect(new TextDecoder().decode(value)).toContain("ready");
+
+  // Send SIGINT
+  process.kill(proc.pid, "SIGINT");
+
+  // Collect remaining output
+  let output = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    output += new TextDecoder().decode(value);
+  }
+
+  const exitCode = await proc.exited;
+
+  expect(output).toContain("received SIGINT");
+  expect(exitCode).toBe(42);
+});
diff --git a/test/regression/issue/ctrl-c.test.ts b/test/regression/issue/ctrl-c.test.ts
index 1ae62b25e0..353246c0b4 100644
--- a/test/regression/issue/ctrl-c.test.ts
+++ b/test/regression/issue/ctrl-c.test.ts
@@ -2,6 +2,73 @@ import { expect, it, test } from "bun:test";
 import { bunEnv, bunExe, isWindows, tempDirWithFiles } from "harness";
 import { join } from "path";
 
+// Test that bun run properly waits for child to handle SIGINT
+// On Windows, we skip this because process.kill uses TerminateProcess (not a real signal).
+// The Windows CTRL+C fix is tested manually - GenerateConsoleCtrlEvent would affect the test runner too.
+test.skipIf(isWindows)("bun run forwards SIGINT to child and waits for graceful exit", async () => {
+  const dir = tempDirWithFiles("ctrlc-forward", {
+    "server.js": /*js*/ `
+      // Simple script that handles SIGINT gracefully
+      console.log("ready");
+
+      process.on("SIGINT", () => {
+        console.log("received SIGINT, shutting down gracefully");
+        process.exit(42);
+      });
+
+      // Keep alive
+      setTimeout(() => {}, 999999);
+    `,
+    "package.json": JSON.stringify({
+      name: "ctrlc-forward",
+      scripts: {
+        start: "bun server.js",
+      },
+    }),
+  });
+
+  const proc = Bun.spawn({
+    cmd: [bunExe(), "run", "start"],
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: bunEnv,
+  });
+
+  // Collect all stdout
+  const chunks: Uint8Array[] = [];
+  const reader = proc.stdout.getReader();
+
+  // Wait for "ready" signal
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    const text = new TextDecoder().decode(value);
+    if (text.includes("ready")) break;
+  }
+
+  // Send SIGINT to bun run process
+  process.kill(proc.pid, "SIGINT");
+
+  // Read remaining output
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  reader.releaseLock();
+
+  // Wait for exit
+  const exitCode = await proc.exited;
+  const stdout = new TextDecoder().decode(Buffer.concat(chunks.map(c => Buffer.from(c))));
+
+  // Verify the child received and handled SIGINT
+  expect(stdout).toContain("ready");
+  expect(stdout).toContain("received SIGINT");
+  expect(exitCode).toBe(42);
+});
+
 test.skipIf(isWindows)("verify that we can call sigint 4096 times", () => {
   const dir = tempDirWithFiles("ctrlc", {
     "index.js": /*js*/ `