prompt, alert, confirm: run JS signal listeners while waiting for input

src/bun_core/output.rs

@@ -2687,6 +2687,12 @@ impl BufferedStdin {
         self
     }
 
+    /// `true` when the next `read_byte` is served from the buffer and does not touch the fd.
+    #[inline]
+    pub fn has_buffered(&self) -> bool {
+        self.start < self.end
+    }
+
     /// Fill `dest` from the buffer, refilling from
     /// the underlying fd until `dest` is full or EOF. Returns `Ok(0)` on EOF.
     ///

src/jsc/PosixSignalHandle.rs

@@ -43,6 +43,32 @@ impl PosixSignalHandle {
             event_loop.enqueue_task(task);
         }
     }
+
+    #[cfg(unix)]
+    fn main_thread() -> Option<bun_ptr::BackRef<Self>> {
+        let vm = VirtualMachine::get_main_thread_vm()?;
+        // SAFETY: `vm` and its event loop are process-lifetime; only the
+        // `signal_handler` slot is read.
+        unsafe { (*(*vm).event_loop()).signal_handler }
+    }
+
+    /// `true` when a signal handler has queued a signal the main thread has not consumed.
+    #[cfg(unix)]
+    pub fn has_queued() -> bool {
+        Self::main_thread().is_some_and(|handler| !handler.ring.is_empty())
+    }
+
+    /// Runs the JS listeners for every queued signal now, for a host function that
+    /// blocks the JS thread (`prompt()`). Main thread only, the ring's single consumer.
+    #[cfg(unix)]
+    pub fn run_queued_from_js_thread(global_object: &JSGlobalObject) {
+        let Some(handler) = Self::main_thread() else {
+            return;
+        };
+        while let Some(signal) = handler.ring.dequeue() {
+            PosixSignalTask::run_from_js_thread(signal, global_object);
+        }
+    }
 }
 
 /// This is the signal handler entry point. Calls enqueue on the ring buffer.

src/runtime/webcore/prompt.rs

@@ -6,6 +6,62 @@ use bun_core::EncodedSlice;
 use bun_core::Output;
 use bun_jsc::EncodedSliceJsc as _;
 
+/// Waits until stdin is readable and runs queued JS signal listeners meanwhile.
+/// Signal handlers are SA_RESTART, so `read(2)` never sees EINTR; `pselect(2)`
+/// does, and the mask closes the gap between the queue check and the wait.
+#[cfg(unix)]
+fn wait_for_stdin(global: &JSGlobalObject) {
+    use bun_jsc::PosixSignalHandle;
+
+    let fd = bun_sys::Fd::stdin().native();
+    loop {
+        PosixSignalHandle::run_queued_from_js_thread(global);
+
+        // SAFETY: zeroed `sigset_t` and `fd_set` are valid inputs to
+        // `sigfillset` and `FD_SET`, which fill them; `fd` is stdin, below
+        // FD_SETSIZE; `previous` is written by `pthread_sigmask` before
+        // `pselect` reads it.
+        let interrupted = unsafe {
+            let mut all: libc::sigset_t = core::mem::zeroed();
+            let mut previous: libc::sigset_t = core::mem::zeroed();
+            libc::sigfillset(&mut all);
+            libc::pthread_sigmask(libc::SIG_BLOCK, &all, &mut previous);
+
+            let interrupted = PosixSignalHandle::has_queued() || {
+                let mut readable: libc::fd_set = core::mem::zeroed();
+                libc::FD_SET(fd, &mut readable);
+                let rc = libc::pselect(
+                    fd + 1,
+                    &mut readable,
+                    core::ptr::null_mut(),
+                    core::ptr::null_mut(),
+                    core::ptr::null(),
+                    &previous,
+                );
+                rc < 0 && bun_sys::last_errno() == libc::EINTR
+            };
+
+            libc::pthread_sigmask(libc::SIG_SETMASK, &previous, core::ptr::null_mut());
+            interrupted
+        };
+        if !interrupted {
+            return;
+        }
+    }
+}
+
+#[cfg(not(unix))]
+fn wait_for_stdin(_global: &JSGlobalObject) {}
+
+/// `alert()` and `confirm()` read unbuffered, so every byte waits on the fd.
+fn take_byte(
+    global: &JSGlobalObject,
+    reader: &mut bun_core::output::StdinReader,
+) -> bun_core::CrateResult<u8> {
+    wait_for_stdin(global);
+    reader.take_byte()
+}
+
 /// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-alert
 #[bun_jsc::host_fn(export = "WebCore__alert")]
 fn alert(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
@@ -51,7 +107,9 @@ fn alert(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     // 7. Optionally, pause while waiting for the user to acknowledge the message.
     let mut reader = Output::stdin_reader();
     loop {
-        let Ok(byte) = reader.take_byte() else { break };
+        let Ok(byte) = take_byte(global, &mut reader) else {
+            break;
+        };
         if byte == b'\n' {
             break;
         }
@@ -105,7 +163,7 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     // 6. Pause until the user responds either positively or negatively.
     let mut reader = Output::stdin_reader();
 
-    let Ok(first_byte) = reader.take_byte() else {
+    let Ok(first_byte) = take_byte(global, &mut reader) else {
         return Ok(JSValue::FALSE);
     };
 
@@ -116,7 +174,7 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     match first_byte {
         b'\n' => return Ok(JSValue::FALSE),
         b'\r' => {
-            let Ok(next_byte) = reader.take_byte() else {
+            let Ok(next_byte) = take_byte(global, &mut reader) else {
                 // They may have said yes, but the stdin is invalid.
                 return Ok(JSValue::FALSE);
             };
@@ -125,7 +183,7 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
             }
         }
         b'y' | b'Y' => {
-            let Ok(next_byte) = reader.take_byte() else {
+            let Ok(next_byte) = take_byte(global, &mut reader) else {
                 // They may have said yes, but the stdin is invalid.
 
                 return Ok(JSValue::FALSE);
@@ -137,7 +195,7 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
                 return Ok(JSValue::TRUE);
             } else if next_byte == b'\r' {
                 // Check Windows style
-                let Ok(second_byte) = reader.take_byte() else {
+                let Ok(second_byte) = take_byte(global, &mut reader) else {
                     return Ok(JSValue::FALSE);
                 };
                 if second_byte == b'\n' {
@@ -148,7 +206,7 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         _ => {}
     }
 
-    while let Ok(b) = reader.take_byte() {
+    while let Ok(b) = take_byte(global, &mut reader) {
         if b == b'\n' || b == b'\r' {
             break;
         }
@@ -172,17 +230,26 @@ pub mod prompt {
     }
 
     /// Small trait exposing `read_byte() -> Result<u8, _>`; the only
-    /// concrete impl is the process-global `BufferedStdin`.
+    /// concrete impl is [`InterruptibleStdin`].
     pub trait ReadByte {
         type Error;
         fn read_byte(&mut self) -> Result<u8, Self::Error>;
     }
 
-    impl ReadByte for bun_core::output::BufferedStdin {
+    /// The process-global `BufferedStdin`; calls [`wait_for_stdin`] before each refill.
+    pub(crate) struct InterruptibleStdin<'a> {
+        global: &'a JSGlobalObject,
+        reader: &'a mut bun_core::output::BufferedStdin,
+    }
+
+    impl ReadByte for InterruptibleStdin<'_> {
         type Error = bun_core::Error;
         #[inline]
         fn read_byte(&mut self) -> Result<u8, Self::Error> {
-            bun_core::output::BufferedStdin::read_byte(self)
+            if !self.reader.has_buffered() {
+                wait_for_stdin(self.global);
+            }
+            self.reader.read_byte()
         }
     }
 
@@ -306,8 +373,10 @@ pub mod prompt {
         // `bun.Output.buffered_stdin.reader()` — process-global 4 KiB buffered stdin.
         // SAFETY: process-global static; prompt() runs single-threaded on the JS
         // main thread, so the exclusive borrow is sound for this scope.
-        let reader: &mut bun_core::output::BufferedStdin =
-            unsafe { &mut *Output::buffered_stdin_reader() };
+        let mut reader = InterruptibleStdin {
+            global,
+            reader: unsafe { &mut *Output::buffered_stdin_reader() },
+        };
         let mut second_byte: Option<u8> = None;
         let Ok(first_byte) = reader.read_byte() else {
             // 8. Let result be null if the user aborts, or otherwise the string
@@ -341,7 +410,7 @@ pub mod prompt {
         // size to 4096. If that is too small, then just dynamically allocate
         // the rest.
         if let Err(e) = read_until_delimiter_array_list_append_assume_capacity(
-            &mut *reader,
+            &mut reader,
             &mut input,
             b'\n',
             2048,
@@ -355,7 +424,7 @@ pub mod prompt {
             input.ensure_total_capacity(4096);
 
             if let Err(e2) = read_until_delimiter_array_list_append_assume_capacity(
-                &mut *reader,
+                &mut reader,
                 &mut input,
                 b'\n',
                 4096,
@@ -366,8 +435,7 @@ pub mod prompt {
                     return Ok(JSValue::NULL);
                 }
 
-                if read_until_delimiter_array_list_infinity(&mut *reader, &mut input, b'\n')
-                    .is_err()
+                if read_until_delimiter_array_list_infinity(&mut reader, &mut input, b'\n').is_err()
                 {
                     // 8. Let result be null if the user aborts, or otherwise the string
                     //    that the user responded with.

src/threading/signal_ring.rs

@@ -72,6 +72,12 @@ impl<const CAPACITY: usize> SignalRing<CAPACITY> {
         }
     }
 
+    /// `true` when no producer has claimed a slot since the last `dequeue`.
+    pub fn is_empty(&self) -> bool {
+        let (head, tail) = unpack(self.state.load(Ordering::Acquire));
+        head == tail
+    }
+
     /// Consumer side, one thread only. Returns the oldest published signal.
     /// `None` means empty, or that the oldest claimed slot is still 0 because
     /// its producer has not stored yet: come back after that producer's

test/js/web/web-globals.test.js

@@ -1,5 +1,5 @@
 import { spawn } from "bun";
-import { expect, it, test } from "bun:test";
+import { describe, expect, it, test } from "bun:test";
 import { bunEnv, bunExe, isLinux, isMacOS, isWindows, tempDir, withoutAggressiveGC } from "harness";
 
 test("exists", () => {
@@ -419,6 +419,65 @@ test("confirm (no) windows newline", async () => {
   expect(await proc.stderr.text()).toBe("No\n");
 });
 
+// prompt(), confirm() and alert() block the JS thread on stdin. A JS signal
+// listener must still run when the signal arrives, not after the next line.
+describe.skipIf(isWindows)("dialogs run JS signal listeners while they wait for input", () => {
+  async function run(dialog, signal, code) {
+    const script = `
+      process.on(${JSON.stringify(signal)}, () => { console.error("[listener ran]"); process.exit(${code}); });
+      const answer = ${dialog};
+      console.error("[code after the dialog ran with " + JSON.stringify(answer) + "]");
+    `;
+    await using proc = spawn({ cmd: [bunExe(), "-e", script], stdio: ["pipe", "pipe", "pipe"], env: bunEnv });
+
+    // The dialog text is flushed right before the child waits on stdin.
+    const reader = proc.stdout.getReader();
+    let shown = "";
+    while (!shown.includes("? ")) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      shown += Buffer.from(value).toString();
+    }
+    proc.kill(signal);
+    // Then answer the dialog. Without the fix the answer is consumed first and
+    // the code after the dialog runs. With it the child may already be gone,
+    // so a closed pipe (EPIPE) is the expected outcome, not a failure.
+    try {
+      proc.stdin.write("bob\n");
+      await proc.stdin.end();
+    } catch (e) {
+      if (e?.code !== "EPIPE") throw e;
+    }
+
+    const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+    return { shown, stderr, exitCode };
+  }
+
+  test.concurrent("prompt() and SIGINT", async () => {
+    expect(await run('prompt("name?")', "SIGINT", 130)).toEqual({
+      shown: "name? ",
+      stderr: "[listener ran]\n",
+      exitCode: 130,
+    });
+  });
+
+  test.concurrent("confirm() and SIGTERM", async () => {
+    expect(await run('confirm("sure?")', "SIGTERM", 143)).toEqual({
+      shown: "sure? [y/N] ",
+      stderr: "[listener ran]\n",
+      exitCode: 143,
+    });
+  });
+
+  test.concurrent("alert() and SIGINT", async () => {
+    expect(await run('alert("done?")', "SIGINT", 130)).toEqual({
+      shown: "done? [Enter] ",
+      stderr: "[listener ran]\n",
+      exitCode: 130,
+    });
+  });
+});
+
 test("globalThis.self = 123 works", () => {
   expect(Object.getOwnPropertyDescriptor(globalThis, "self")).toMatchObject({
     configurable: true,