fix(test): eliminate race in exit-on-ctrlc output ordering

Move "ctrl-c received" print from the signal handler to the main thread
(after OnceLock::wait), so it always executes after the milestone flush
println!(). Previously, std::process::exit(0) in the handler could
terminate before output reached the PTY, causing flaky snapshot diffs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

crates/vite_task_bin/src/vtt/exit_on_ctrlc.rs

@@ -1,3 +1,110 @@
+use std::sync::Arc;
+
+/// Write a milestone directly to the controlling terminal, bypassing stdout.
+///
+/// In labeled/piped modes stdout is a pipe and milestones would be stuck in
+/// the line-buffered writer until a newline arrives. This function writes to
+/// the terminal directly so the milestone reaches the PTY regardless of how
+/// stdout is configured.
+#[cfg(unix)]
+fn write_milestone_to_tty(name: &str) {
+    use std::io::Write;
+    let milestone = pty_terminal_test_client::encoded_milestone(name);
+    let mut tty = std::fs::OpenOptions::new().write(true).open("/dev/tty").unwrap();
+    tty.write_all(&milestone).unwrap();
+    tty.flush().unwrap();
+}
+
+/// Write a milestone directly to the console output with VT processing enabled.
+///
+/// Opens `CONOUT$` via `CreateFileW`, enables `ENABLE_VIRTUAL_TERMINAL_PROCESSING`
+/// so OSC 8 sequences are interpreted by the console, then writes the milestone
+/// via [`WriteConsoleW`]. `ConPTY` monitors the console buffer and forwards the
+/// resulting VT output to the PTY master.
+#[cfg(windows)]
+fn write_milestone_to_tty(name: &str) {
+    use std::ffi::c_void;
+
+    // SAFETY: These are stable Windows API functions with well-defined behavior.
+    unsafe extern "system" {
+        fn CreateFileW(
+            name: *const u16,
+            access: u32,
+            share: u32,
+            security: *const c_void,
+            disposition: u32,
+            flags: u32,
+            template: *const c_void,
+        ) -> *mut c_void;
+        fn GetConsoleMode(handle: *mut c_void, mode: *mut u32) -> i32;
+        fn SetConsoleMode(handle: *mut c_void, mode: u32) -> i32;
+        fn WriteConsoleW(
+            handle: *mut c_void,
+            buffer: *const u16,
+            chars_to_write: u32,
+            chars_written: *mut u32,
+            reserved: *const c_void,
+        ) -> i32;
+        fn CloseHandle(handle: *mut c_void) -> i32;
+    }
+
+    const GENERIC_READ: u32 = 0x8000_0000;
+    const GENERIC_WRITE: u32 = 0x4000_0000;
+    const FILE_SHARE_WRITE: u32 = 0x0000_0002;
+    const OPEN_EXISTING: u32 = 3;
+    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
+    const INVALID_HANDLE: *mut c_void = -1_isize as *mut c_void;
+
+    let conout: Vec<u16> = "CONOUT$\0".encode_utf16().collect();
+
+    // SAFETY: Opening CONOUT$ with read/write access to query and set console mode.
+    let handle = unsafe {
+        CreateFileW(
+            conout.as_ptr(),
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_WRITE,
+            std::ptr::null(),
+            OPEN_EXISTING,
+            0,
+            std::ptr::null(),
+        )
+    };
+    assert!(handle != INVALID_HANDLE, "failed to open CONOUT$");
+
+    // Enable VT processing so OSC 8 sequences are interpreted.
+    let mut mode: u32 = 0;
+    // SAFETY: `handle` is a valid console output handle from `CreateFileW`.
+    // `GetConsoleMode` writes the current mode into `mode`.
+    unsafe { GetConsoleMode(handle, &raw mut mode) };
+    // SAFETY: Setting the console mode with VT processing enabled.
+    unsafe { SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) };
+
+    // Encode the milestone as a UTF-8 string, then convert to UTF-16 for
+    // `WriteConsoleW`.
+    let milestone = pty_terminal_test_client::encoded_milestone(name);
+    let milestone_str = String::from_utf8(milestone).expect("milestone is valid UTF-8");
+    let wide: Vec<u16> = milestone_str.encode_utf16().collect();
+
+    let mut written: u32 = 0;
+    // SAFETY: `handle` is valid, `wide` is a valid UTF-16 buffer. `WriteConsoleW`
+    // writes up to `wide.len()` characters and stores the count in `written`.
+    unsafe {
+        WriteConsoleW(
+            handle,
+            wide.as_ptr(),
+            wide.len().try_into().unwrap(),
+            &raw mut written,
+            std::ptr::null(),
+        );
+    }
+
+    // SAFETY: Restoring original console mode and closing the handle.
+    unsafe {
+        SetConsoleMode(handle, mode);
+        CloseHandle(handle);
+    }
+}
+
 /// exit-on-ctrlc
 ///
 /// Sets up a Ctrl+C handler, emits a "ready" milestone, then waits.
@@ -25,19 +132,26 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    ctrlc::set_handler(move || {
-        use std::io::Write;
-        let _ = write!(std::io::stdout(), "ctrl-c received");
-        let _ = std::io::stdout().flush();
-        std::process::exit(0);
+    let ctrlc_once_lock = Arc::new(std::sync::OnceLock::<()>::new());
+
+    ctrlc::set_handler({
+        let ctrlc_once_lock = Arc::clone(&ctrlc_once_lock);
+        move || {
+            let _ = ctrlc_once_lock.set(());
+        }
     })?;
 
-    pty_terminal_test_client::mark_milestone("ready");
-    // Print a newline so the milestone bytes get flushed through line-buffered
-    // writers (labeled/grouped log modes).
-    println!();
+    // Write the milestone directly to the controlling terminal, bypassing
+    // stdout. In labeled/piped modes stdout is a pipe and milestones would
+    // be stuck in the line-buffered writer until a newline arrives.
+    //
+    // On Unix: /dev/tty opens the controlling terminal (the PTY).
+    // On Windows: open CONOUT$ with ENABLE_VIRTUAL_TERMINAL_PROCESSING so
+    // OSC 8 sequences are processed by the console, then forwarded by ConPTY
+    // to the PTY output.
+    write_milestone_to_tty("ready");
 
-    loop {
-        std::thread::park();
-    }
+    ctrlc_once_lock.wait();
+    println!("ctrl-c received");
+    Ok(())
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots/ctrl-c terminates running tasks (cached).snap

@@ -7,5 +7,4 @@ expression: e2e_outputs
 $ vtt exit-on-ctrlc
 @ write-key: ctrl-c
 $ vtt exit-on-ctrlc
-
 ctrl-c received

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots/ctrl-c terminates running tasks (labeled).snap

@@ -5,9 +5,6 @@ expression: e2e_outputs
 > vt run --log=labeled dev
 @ expect-milestone: ready
 [ctrl-c-test#dev] $ vtt exit-on-ctrlc ⊘ cache disabled
-[ctrl-c-test#dev] 
 @ write-key: ctrl-c
 [ctrl-c-test#dev] $ vtt exit-on-ctrlc ⊘ cache disabled
-[ctrl-c-test#dev] 
-
 [ctrl-c-test#dev] ctrl-c received

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots/ctrl-c terminates running tasks.snap

@@ -7,5 +7,4 @@ expression: e2e_outputs
 $ vtt exit-on-ctrlc ⊘ cache disabled
 @ write-key: ctrl-c
 $ vtt exit-on-ctrlc ⊘ cache disabled
-
 ctrl-c received