Watch folders based on BuildState (#8219)

* Watch folders based on BuildState

* Add additional test cases

* Code review feedback

* Make test cross plat (I hope)

* Avoids sleeps in test

* Log error when source folder does not exist.

* Add changelog entry

* Code review feedback

* Avoid race condition (I hope)

* Trigger CI

Author: nojaf

AGENTS.md

@@ -389,6 +389,20 @@ make test-rewatch     # Run integration tests
 
 **Integration Tests**: The `make test-rewatch` command runs bash-based integration tests located in `rewatch/tests/suite.sh`. These tests use the `rewatch/testrepo/` directory as a test workspace with various package configurations to verify rewatch's behavior across different scenarios.
 
+**Running Individual Integration Tests**: You can run individual test scripts directly by setting up the environment manually:
+
+```bash
+cd rewatch/tests
+export REWATCH_EXECUTABLE="$(realpath ../target/debug/rescript)"
+eval $(node ./get_bin_paths.js)
+export RESCRIPT_BSC_EXE
+export RESCRIPT_RUNTIME
+source ./utils.sh
+bash ./watch/06-watch-missing-source-folder.sh
+```
+
+This is useful for iterating on a specific test without running the full suite.
+
 #### Debugging
 
 - **Build State**: Use `log::debug!` to inspect `BuildState` contents
@@ -411,8 +425,16 @@ export RESCRIPT_RUNTIME=$(realpath packages/@rescript/runtime)
 cargo run --manifest-path rewatch/Cargo.toml -- build
 ```
 
+Note that the dev binary is `./rewatch/target/debug/rescript`, not `rewatch`. The binary name is `rescript` because that's the package name in `Cargo.toml`.
+
 This is useful when testing rewatch changes against local compiler modifications without running a full `make` build cycle.
 
+Use `-v` for info-level logging or `-vv` for debug-level logging (e.g., to see which folders are being watched in watch mode):
+
+```bash
+cargo run --manifest-path rewatch/Cargo.toml -- -vv watch <folder>
+```
+
 #### Performance Considerations
 
 - **Incremental Builds**: Only recompile dirty modules
@@ -467,3 +489,9 @@ When clippy suggests refactoring that could impact performance, consider the tra
 2. Update `AsyncWatchArgs` for new parameters
 3. Handle different file types (`.res`, `.resi`, etc.)
 4. Consider performance impact of watching many files
+
+## CI Gotchas
+
+- **`sleep` is fragile** — Prefer polling (e.g., `wait_for_file`) over fixed sleeps. CI runners are slower than local machines.
+- **`exit_watcher` is async** — It only signals the watcher to stop (removes the lock file), it doesn't wait for the process to exit. Avoid triggering config-change events before exiting, as the watcher may start a concurrent rebuild.
+- **`sed -i` differs across platforms** — macOS requires `sed -i '' ...`, Linux does not. Use the `replace` / `normalize_paths` helpers from `rewatch/tests/utils.sh` instead of raw `sed`.

CHANGELOG.md

@@ -24,6 +24,8 @@
 
 #### :nail_care: Polish
 
+- Build system: Watch only source folders from build state instead of the entire project directory, and report missing configured source folders. https://github.com/rescript-lang/rescript/pull/8219
+
 #### :house: Internal
 
 # 13.0.0-alpha.1

rewatch/src/watcher.rs

@@ -1,7 +1,8 @@
 use crate::build;
-use crate::build::build_types::SourceType;
+use crate::build::build_types::{BuildCommandState, SourceType};
 use crate::build::clean;
 use crate::cmd;
+use crate::config;
 use crate::helpers;
 use crate::helpers::StrippedVerbatimPath;
 use crate::helpers::emojis::*;
@@ -12,7 +13,7 @@ use anyhow::{Context, Result};
 use futures_timer::Delay;
 use notify::event::ModifyKind;
 use notify::{Config, Error, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
@@ -57,32 +58,116 @@ fn matches_filter(path_buf: &Path, filter: &Option<regex::Regex>) -> bool {
     filter.as_ref().map(|re| !re.is_match(&name)).unwrap_or(true)
 }
 
+/// Computes the list of paths to watch based on the build state.
+/// Returns tuples of (path, recursive_mode) for each watch target.
+fn compute_watch_paths(build_state: &BuildCommandState, root: &Path) -> Vec<(PathBuf, RecursiveMode)> {
+    // Use a HashMap to deduplicate paths, giving precedence to Recursive mode
+    // when the same path appears with different modes (e.g. package root watched
+    // NonRecursively for rescript.json changes, but also as a source folder with
+    // Recursive mode).
+    let mut watch_paths: std::collections::HashMap<PathBuf, RecursiveMode> = std::collections::HashMap::new();
+
+    let mut insert = |path: PathBuf, mode: RecursiveMode| {
+        watch_paths
+            .entry(path)
+            .and_modify(|existing| {
+                if mode == RecursiveMode::Recursive {
+                    *existing = RecursiveMode::Recursive;
+                }
+            })
+            .or_insert(mode);
+    };
+
+    for (_, package) in build_state.build_state.packages.iter() {
+        if !package.is_local_dep {
+            continue;
+        }
+
+        // Watch the package root non-recursively to detect rescript.json changes.
+        // We watch the directory rather than the file directly because many editors
+        // use atomic writes (delete + recreate or write to temp + rename) which would
+        // cause a direct file watch to be lost after the first edit.
+        insert(package.path.clone(), RecursiveMode::NonRecursive);
+
+        // Watch each source folder
+        for source in &package.source_folders {
+            let dir = package.path.join(&source.dir);
+            if !dir.exists() {
+                log::error!(
+                    "Could not read folder: {:?}. Specified in dependency: {}, located {:?}...",
+                    source.dir,
+                    package.name,
+                    package.path
+                );
+                continue;
+            }
+            let mode = match &source.subdirs {
+                Some(config::Subdirs::Recurse(true)) => RecursiveMode::Recursive,
+                _ => RecursiveMode::NonRecursive,
+            };
+            insert(dir, mode);
+        }
+    }
+
+    // Watch the lib/ directory for the lockfile (rescript.lock lives in lib/)
+    let lib_dir = root.join("lib");
+    if lib_dir.exists() {
+        insert(lib_dir, RecursiveMode::NonRecursive);
+    }
+
+    watch_paths.into_iter().collect()
+}
+
+/// Registers all watch paths with the given watcher.
+fn register_watches(watcher: &mut RecommendedWatcher, watch_paths: &[(PathBuf, RecursiveMode)]) {
+    for (path, mode) in watch_paths {
+        let mode_str = if *mode == RecursiveMode::Recursive {
+            "recursive"
+        } else {
+            "non-recursive"
+        };
+        log::debug!("  watching ({mode_str}): {}", path.display());
+        if let Err(e) = watcher.watch(path, *mode) {
+            log::error!("Could not watch {}: {}", path.display(), e);
+        }
+    }
+}
+
+/// Unregisters all watch paths from the given watcher.
+fn unregister_watches(watcher: &mut RecommendedWatcher, watch_paths: &[(PathBuf, RecursiveMode)]) {
+    for (path, _) in watch_paths {
+        let _ = watcher.unwatch(path);
+    }
+}
+
 struct AsyncWatchArgs<'a> {
+    watcher: &'a mut RecommendedWatcher,
+    current_watch_paths: Vec<(PathBuf, RecursiveMode)>,
+    initial_build_state: BuildCommandState,
     q: Arc<FifoQueue<Result<Event, Error>>>,
     path: &'a Path,
     show_progress: bool,
     filter: &'a Option<regex::Regex>,
     after_build: Option<String>,
     create_sourcedirs: bool,
     plain_output: bool,
-    warn_error: Option<String>,
 }
 
 async fn async_watch(
     AsyncWatchArgs {
+        watcher,
+        mut current_watch_paths,
+        initial_build_state,
         q,
         path,
         show_progress,
         filter,
         after_build,
         create_sourcedirs,
         plain_output,
-        warn_error,
     }: AsyncWatchArgs<'_>,
 ) -> Result<()> {
-    let mut build_state: build::build_types::BuildCommandState =
-        build::initialize_build(None, filter, show_progress, path, plain_output, warn_error)
-            .with_context(|| "Could not initialize build")?;
+    let mut build_state = initial_build_state;
     let mut needs_compile_type = CompileType::Incremental;
     // create a mutex to capture if ctrl-c was pressed
     let ctrlc_pressed = Arc::new(Mutex::new(false));
@@ -128,6 +213,21 @@ async fn async_watch(
                 return Ok(());
             }
 
+            // Detect rescript.json changes and trigger a full rebuild
+            if event
+                .paths
+                .iter()
+                .any(|p| p.file_name().map(|name| name == "rescript.json").unwrap_or(false))
+                && matches!(
+                    event.kind,
+                    EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
+                )
+            {
+                log::debug!("rescript.json changed -> full compile");
+                needs_compile_type = CompileType::Full;
+                continue;
+            }
+
             let paths = event
                 .paths
                 .iter()
@@ -280,6 +380,12 @@ async fn async_watch(
                     build_state.get_warn_error_override(),
                 )
                 .expect("Could not initialize build");
+
+                // Re-register watches based on the new build state
+                unregister_watches(watcher, &current_watch_paths);
+                current_watch_paths = compute_watch_paths(&build_state, path);
+                register_watches(watcher, &current_watch_paths);
+
                 let _ = build::incremental_build(
                     &mut build_state,
                     None,
@@ -334,23 +440,34 @@ pub fn start(
         let mut watcher = RecommendedWatcher::new(move |res| producer.push(res), Config::default())
             .expect("Could not create watcher");
 
-        log::debug!("watching {folder}");
+        let path = Path::new(folder);
 
-        watcher
-            .watch(Path::new(folder), RecursiveMode::Recursive)
-            .expect("Could not start watcher");
+        // Do an initial build to discover packages and source folders
+        let build_state: BuildCommandState = build::initialize_build(
+            None,
+            filter,
+            show_progress,
+            path,
+            plain_output,
+            warn_error.clone(),
+        )
+        .with_context(|| "Could not initialize build")?;
 
-        let path = Path::new(folder);
+        // Compute and register targeted watches based on source folders
+        let current_watch_paths = compute_watch_paths(&build_state, path);
+        register_watches(&mut watcher, &current_watch_paths);
 
         async_watch(AsyncWatchArgs {
+            watcher: &mut watcher,
+            current_watch_paths,
+            initial_build_state: build_state,
             q: consumer,
             path,
             show_progress,
             filter,
             after_build,
             create_sourcedirs,
             plain_output,
-            warn_error: warn_error.clone(),
         })
         .await
     })

rewatch/tests/lock/01-lock-when-watching.sh

@@ -17,11 +17,6 @@ else
   exit 1
 fi
 
-exit_watcher() {
-  # kill watcher by removing lock file
-  rm lib/rescript.lock
-}
-
 rewatch_bg watch > /dev/null 2>&1 &
 success "Watcher Started"
 

rewatch/tests/suite.sh

@@ -28,6 +28,15 @@ fi
 
 source ./utils.sh
 
+bold "Check for stale rescript processes"
+STALE_PIDS=$(ps aux | grep "$REWATCH_EXECUTABLE" | grep -v grep | awk '{print $2}')
+if [ -n "$STALE_PIDS" ]; then
+  error "Found stale rescript processes using this executable:"
+  ps aux | grep "$REWATCH_EXECUTABLE" | grep -v grep
+  exit 1
+fi
+success "No stale rescript processes found"
+
 bold "Yarn install"
 (cd ../testrepo && yarn && cp node_modules/rescript-nodejs/bsconfig.json node_modules/rescript-nodejs/rescript.json)
 
@@ -77,6 +86,10 @@ fi
 # Watch tests
 ./watch/01-watch-recompile.sh &&
 ./watch/02-watch-warnings-persist.sh &&
+./watch/03-watch-new-file.sh &&
+./watch/04-watch-config-change.sh &&
+./watch/05-watch-ignores-non-source.sh &&
+./watch/06-watch-missing-source-folder.sh &&
 
 # Lock tests
 ./lock/01-lock-when-watching.sh &&

rewatch/tests/utils.sh

@@ -50,3 +50,27 @@ replace() {
     sed -i $1 $2;
   fi
 }
+
+exit_watcher() {
+  rm -f lib/rescript.lock
+}
+
+wait_for_file() {
+  local file="$1"; local timeout="${2:-30}"
+  while [ "$timeout" -gt 0 ]; do
+    [ -f "$file" ] && return 0
+    sleep 1
+    timeout=$((timeout - 1))
+  done
+  return 1
+}
+
+wait_for_file_gone() {
+  local file="$1"; local timeout="${2:-30}"
+  while [ "$timeout" -gt 0 ]; do
+    [ ! -f "$file" ] && return 0
+    sleep 1
+    timeout=$((timeout - 1))
+  done
+  return 1
+}

rewatch/tests/watch/01-watch-recompile.sh

@@ -15,22 +15,6 @@ else
   exit 1
 fi
 
-exit_watcher() {
-  # kill watcher by removing lock file
-  rm lib/rescript.lock
-}
-
-# Wait until a file exists (with timeout in seconds, default 30)
-wait_for_file() {
-  local file="$1"; local timeout="${2:-30}"
-  while [ "$timeout" -gt 0 ]; do
-    [ -f "$file" ] && return 0
-    sleep 1
-    timeout=$((timeout - 1))
-  done
-  return 1
-}
-
 # Start watcher and capture logs for debugging
 rewatch_bg watch > rewatch.log 2>&1 &
 success "Watcher Started"

rewatch/tests/watch/02-watch-warnings-persist.sh

@@ -15,11 +15,6 @@ else
   exit 1
 fi
 
-exit_watcher() {
-  # kill watcher by removing lock file
-  rm -f lib/rescript.lock
-}
-
 # Wait until a pattern appears in a file (with timeout in seconds, default 30)
 wait_for_pattern() {
   local file="$1"; local pattern="$2"; local timeout="${3:-30}"