fix(core): use recursive FSEvents on macOS instead of non-recursive kqueue (#34523)

## Current Behavior

Since Nx 22.5.0, the daemon's native file watcher silently drops all
file change events on macOS in large monorepos (~5,250+ watched
directories). `nx watch`, `nx serve`, and any daemon-dependent file
watching is broken.

The root cause is that #34329 switched all watched paths to
`WatchedPath::non_recursive()`. On macOS, the `notify` crate uses
**kqueue** for non-recursive watches instead of **FSEvents**. kqueue
silently fails at scale due to vnode table pressure (`kern.num_vnodes ==
kern.maxvnodes`), causing the daemon to never detect file changes.

This is a **scale-dependent** bug: it works fine in small workspaces
(~30 directories) but breaks silently in large ones.

| | **Nx 22.4.5** | **Nx 22.5.0+** |
|---|---|---|
| **Small repo (~30 dirs)** | Works (FSEvents) | Works (~30 kqueue
watches) |
| **Large repo (~5,250+ dirs)** | Works (FSEvents) | **Broken** (kqueue
silently drops all events) |

## Expected Behavior

The macOS file watcher should detect file creates, modifications, and
deletions at any scale, matching the behavior of Nx 22.4.x.

## Fix

Use platform-conditional watch modes:
- **macOS:** Single recursive watch on the workspace root (uses FSEvents
natively)
- **Linux/Windows:** Non-recursive per-directory watches (preserves the
#33781 inotify fix)

On macOS, FSEvents handles recursive watching from a single root path,
so directory enumeration and dynamic registration are skipped entirely.
This also improves daemon startup time on macOS from ~10 minutes to <1
second in a 354-project monorepo.

### What changed in `watcher.rs`

1. **Initial pathset:** On macOS, watch only the root directory
recursively via FSEvents instead of enumerating all directories for
non-recursive kqueue watches.
2. **Dynamic directory registration (`on_action`):** Wrapped in
`#[cfg(not(target_os = "macos"))]` since FSEvents already watches the
full tree.

Linux/Windows behavior is completely unchanged.

### Why the event filter is fine as-is

We verified that with recursive FSEvents watches, macOS emits specific
`FileEventKind` variants (`Create(File)`, `Modify(Data(Content))`,
`Remove(File)`, `Modify(Name(Any))`) that the current
`watch_filterer.rs` already handles correctly. Zero events were rejected
by the catch-all. The `Modify(Any)` / `Create(Any)` variants are kqueue
artifacts that are not needed with FSEvents.

### Why kqueue fails silently

Apple's [File System Events Programming
Guide](https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/FSEvents_ProgGuide/KernelQueues/KernelQueues.html)
explicitly recommends FSEvents over kqueue for large hierarchies: *"If
you are monitoring a large hierarchy of content, you should use file
system events instead."* kqueue requires `open(path, O_EVTONLY)` per
watched directory. Under vnode table pressure, the kernel recycles
vnodes with kqueue watches attached without notifying the watcher. There
is no error, no partial delivery, and no diagnostic signal.

## Tested on

- macOS 26.3 (Tahoe), Apple Silicon (arm64), APFS
- 354-project pnpm monorepo (~19,865 non-ignored directories)
- Verified: file modifications, file creates, and file deletes all
detected
- Daemon init time: ~10 min (with enumeration) -> <1s (with root-only
FSEvents watch)

## Related Issue(s)

Fixes #34522

Co-authored-by: Amp <amp@ampcode.com>

Author: comp615

packages/nx/src/native/watch/watcher.rs

@@ -201,20 +201,26 @@ impl Watcher {
                 return action;
             }
 
-            // Check for new directory creation events and dynamically register watches.
-            // Without this, non-recursive watches would miss changes in newly created dirs.
-            let new_directories = extract_new_directories(&action.events, &ignore_globs_for_action);
-
-            if !new_directories.is_empty() {
-                let mut path_set = watched_path_set_for_action.lock();
-                path_set.extend(new_directories);
-                trace!(
-                    count = path_set.len(),
-                    "updating pathset with new directories"
-                );
-                watch_exec_for_action
-                    .config
-                    .pathset(path_set.iter().map(|p| WatchedPath::non_recursive(p)));
+            // On macOS, FSEvents watches the entire tree recursively from the root,
+            // so we don't need to dynamically register new directories.
+            #[cfg(not(target_os = "macos"))]
+            {
+                // Check for new directory creation events and dynamically register watches.
+                // Without this, non-recursive watches would miss changes in newly created dirs.
+                let new_directories =
+                    extract_new_directories(&action.events, &ignore_globs_for_action);
+
+                if !new_directories.is_empty() {
+                    let mut path_set = watched_path_set_for_action.lock();
+                    path_set.extend(new_directories);
+                    trace!(
+                        count = path_set.len(),
+                        "updating pathset with new directories"
+                    );
+                    watch_exec_for_action
+                        .config
+                        .pathset(path_set.iter().map(|p| WatchedPath::non_recursive(p)));
+                }
             }
 
             let mut origin_path = origin.clone();
@@ -284,16 +290,35 @@ impl Watcher {
         let start = async move {
             trace!("configuring watch exec");
 
-            // Enumerate non-ignored directories and watch each one non-recursively.
-            // This prevents inotify watches on node_modules and other ignored trees.
-            let path_set = enumerate_watch_paths(&origin, use_ignore);
-            trace!(count = path_set.len(), "setting watched paths");
-
-            // Store the initial path set so the on_action handler can append to it
-            watch_exec
-                .config
-                .pathset(path_set.iter().map(|p| WatchedPath::non_recursive(p)));
-            *watched_path_set.lock() = path_set;
+            // On macOS, FSEvents handles recursive watching natively from a single
+            // root path. No need to enumerate individual directories — this avoids
+            // kqueue (used for non-recursive watches) which silently fails at scale
+            // due to vnode table pressure. See #34522.
+            #[cfg(target_os = "macos")]
+            {
+                let mut path_set = HashSet::new();
+                path_set.insert(PathBuf::from(&origin));
+                trace!(
+                    count = path_set.len(),
+                    "macOS: watching root recursively via FSEvents"
+                );
+                watch_exec
+                    .config
+                    .pathset(path_set.iter().map(|p| WatchedPath::recursive(p)));
+                *watched_path_set.lock() = path_set;
+            }
+            // On Linux/Windows, enumerate non-ignored directories and watch each one
+            // non-recursively. This prevents inotify watches on node_modules and other
+            // ignored trees (fixing #33781).
+            #[cfg(not(target_os = "macos"))]
+            {
+                let path_set = enumerate_watch_paths(&origin, use_ignore);
+                trace!(count = path_set.len(), "setting watched paths");
+                watch_exec
+                    .config
+                    .pathset(path_set.iter().map(|p| WatchedPath::non_recursive(p)));
+                *watched_path_set.lock() = path_set;
+            }
 
             watch_exec.config.filterer(watch_filterer::create_filter(
                 &origin,