fix(watcher): serialize watch and close on the native watcher

`NativeWatcher::watch` spawns a detached task that drives the FSEvents backend's
`append_path` (mutating the watcher's CFMutableArray), while `NativeWatcher::close`
drops the watcher (`CFRelease` of that array). Nothing kept the two apart, so the
close-old-then-watch-new restart flow could free the CFArray while a watch task was
still appending to it — a use-after-free that aborts the process on macOS.

Guard every access to the watcher with an async mutex: a watch task acquires it
before touching the watcher and holds it for the whole `watch()`, and `close`
aborts the in-flight task and then acquires the same mutex before tearing the
watcher down. A future can only be cancelled at an `.await`, never mid-FFI, so an
aborted task always releases the guard with the watcher in a consistent state, and
holding the mutex in `close` proves no task is inside `append_path`.

Adds `rspack_napi::runtime::spawn_handle` to retain the JoinHandle needed to abort.

Author: stormslowly

crates/rspack_binding_api/Cargo.toml

@@ -117,7 +117,7 @@ serde                                  = { workspace = true }
 serde_json                             = { workspace = true }
 simd-json                              = { workspace = true }
 swc_core                               = { workspace = true, default-features = false, features = ["ecma_transforms_react"] }
-tokio                                  = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "test-util", "tracing", "parking_lot"] }
+tokio                                  = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "sync", "test-util", "tracing", "parking_lot"] }
 ustr                                   = { workspace = true }
 
 [package.metadata.cargo-shear]

crates/rspack_binding_api/src/native_watcher.rs

@@ -2,6 +2,7 @@ use std::{
   boxed::Box,
   panic::AssertUnwindSafe,
   path::{Path, PathBuf},
+  sync::Arc,
   time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
@@ -59,6 +60,8 @@ pub struct NativeWatchUndelayedEvent {
 pub struct NativeWatcher {
   watcher: FsWatcher,
   closed: bool,
+  watch_task: Option<tokio::task::JoinHandle<()>>,
+  watcher_lock: Arc<tokio::sync::Mutex<()>>,
 }
 
 fn timestamp_to_system_time(millis: u64) -> SystemTime {
@@ -81,6 +84,8 @@ impl NativeWatcher {
     Self {
       watcher,
       closed: false,
+      watch_task: None,
+      watcher_lock: Arc::new(tokio::sync::Mutex::new(())),
     }
   }
 
@@ -110,8 +115,15 @@ impl NativeWatcher {
 
     let start_time = start_time.get_u64().1;
 
+    if let Some(prev) = self.watch_task.take() {
+      prev.abort();
+    }
+
+    let watcher_lock = Arc::clone(&self.watcher_lock);
+    let mut watch_task = None;
     reference.share_with(env, |native_watcher| {
-      rspack_napi::runtime::spawn(async move {
+      watch_task = Some(rspack_napi::runtime::spawn_handle(async move {
+        let _guard = watcher_lock.lock_owned().await;
         native_watcher
           .watcher
           .watch(
@@ -123,9 +135,10 @@ impl NativeWatcher {
             Box::new(js_event_handler_undelayed),
           )
           .await
-      });
+      }));
       Ok(())
     })?;
+    self.watch_task = watch_task;
 
     Ok(())
   }
@@ -160,6 +173,10 @@ impl NativeWatcher {
     let shared_reference = reference.share_with(Env::from_raw(env.raw()), |native_watcher| {
       rspack_napi::runtime::spawn(async move {
         let result = AssertUnwindSafe(async {
+          if let Some(task) = native_watcher.watch_task.take() {
+            task.abort();
+          }
+          let _guard = Arc::clone(&native_watcher.watcher_lock).lock_owned().await;
           native_watcher
             .watcher
             .close()

crates/rspack_napi/src/runtime.rs

@@ -38,6 +38,14 @@ where
   std::mem::drop(spawn_inner(future));
 }
 
+pub fn spawn_handle<F>(future: F) -> tokio::task::JoinHandle<F::Output>
+where
+  F: Future + Send + 'static,
+  F::Output: Send + 'static,
+{
+  spawn_inner(future)
+}
+
 pub fn block_on<F: Future>(future: F) -> F::Output {
   with_runtime(|runtime| runtime.block_on(future))
 }